行动创造奇迹

=============================封装类===============
针对八种基本数据类型定义的相应的引用类型-封装类(包装类，包裹类)
基本数据类型          封装类
 boolean               Boolean
 byte                  Byte
 short                 Short
 int                   Integer
 long                  Long
 char                  Character
 float                 Float
 double                Double
所有的封状类都是一个只读类（不能修改的).针对没个基本类型我们只能建立一个这读的。

class Test
{
 public static void main(String[] args)
 {
  int i=3;
  Integer in=new Integer(i);
  int j=in.intValue();
  System.out.println(j);
  String str=in.toString();  //把Integer对象转换为String类型
  System.out.println("str="+str);
 
  String str1="123";
  System.out.println(Integer.valueOf(str1));  //把String类型转换为Integer类型
 
  boolean b1=false;
  Boolean b=new Boolean(b1);
  String s1=b.toString();
  System.out.println(s1);
 
  String s2="NO";
  System.out.println(Boolean.valueOf(s2));
 }
}

*****************Class*********************
1> 在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后,在生成
   的.class文件中,就会产生一个Class对象，用于表示这个类的类型信息。
2> 获取Class实例的方法有三种:
   <1>利用对象调用getClass()方法获得该对象的Class实例。
   <2>使用Class类的静态方法forName(),用类的名字获取一个Class的是实例。
   <3>运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以用.TYPE来获取相应的
      基本数据类型的Class实例。
   <4>在运行期间，如果我们要产生某个类的对象，JAVA虚拟机(JVM)会检查该类型的Class对象是否被
      加载，如果没有加载,JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已
      经被加载到内存，就可以用它来产生该类型所有的对象。
   <5>newInstance()调用类中缺省的构造方法。(好处是我们在不知道类的名字的情况下去创造一个实例）
import java.lang.reflect.*;       //子包必须手动导入
class ClassTest
{
 public static void main(String[] args)//throws Exception
 {
  /*
  Point pt=new Point();             
  Class c1=pt.getClass();//利用对象调用getClass()方法获得该对象的Class实例
  System.out.println(c1.getName());
 
  Class c2=Class.forName("Point");//使用Class类的静态方法forName(),用类的名字获取一个Class的是实例
  System.out.println(c2.getName());
 
  Class c3=Point.class;//运用.class的方式来获取Class实例
  System.out.println(c3.getName());
 
  Class c4=Integer.TYPE;//封装类用.TYPE来获取相应的基本数据类型的Class实例。
  System.out.println(c4.getName());
  */
  /*
  System.out.println("before new Point()");
  new Point();
  System.out.println("after new Point()");
  Class.forName("Line");
  */
  /*
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Point pt=(Point)c.newInstance();
   pt.output();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  */
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Constructor[] cons=c.getDeclaredConstructors();
   /*
   for(int i=0;i<cons.length;i++)
   {
    System.out.println(cons[i]);
   }
   Method[] ms=c.getDeclaredMethods();
   for(int i=0;i<ms.length;i++)
   {
    System.out.println(ms[i]);
   }*/
   Class[] params=cons[0].getParameterTypes();
   Object[] paramValues=new Object[params.length];
   for(int i=0;i<params.length;i++)
   {
    if(params[i].isPrimitive())
    {
     paramValues[i]=new Integer(i+3);
    }
   }
   Object o=cons[0].newInstance(paramValues);
   Method[] ms=c.getDeclaredMethods();
   ms[0].invoke(o,null);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
 
 }
}

class Point
{
 static
 {
  System.out.println("Loading Point");
 }
 int x,y;
 void output()
 {
  System.out.println("x="+x+","+"y="+y);
 }
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

class Line
{
 static
 {
  System.out.println("Loading Line");
 }
}

~~~~~~~~~~~~~~~~~~~~~~~~~~函数的调用~~~~~~~~~~~~~~~~~~~~
1> 在java中，传参时，都是以传值的形式惊行。
2> 对于基本数据类型，传递的是数据的拷贝，对于引用类型，传递的引用的拷贝。
3> 当我们在打印一个对象的时候，比如System.out.println(pt);，它会自动调用类的toString()方法
   ，所以建议在所有的子类中重写toString()方法。
我们写一个函数用来交换两个变量(x,y)的值.
 code:
class StringTest
{
 public static void change(int x, int y)
 {
  x=x+y;
  y=x-y;
  x=x-y;
 }
 /*
 public static void change(int[] num)
 {
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
 }
 public static void change(Point pt)
 {
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
 }
 */
 public static void main(String[] args)
 {
 int x=3;
 int y=4;
 change(3,4);
 System.out.println("x="+x+","+"y="+y);
 }
我们期望的输出结果是 x=4,y=3 然后你运行后发现结果为x=3,y=4,并没有达到我们的要求,为什么呢?那是因为对于基本数据类型，传递的是数据的拷贝，对于引用类型，传递的是引用(首地址)的拷贝。看看下面的内存图解应该你就能看出来了.看看引用类型怎么来实现:

code:
class StringTest
{
 /*
 public static void change(int x, int y)
 {
  x=x+y;
  y=x-y;
  x=x-y;
 }
 */
 public static void change(int[] num)
 {
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
 }
 public static void change(Point pt)
 {
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
 }
 public static void main(String[] args)
 {
  /*
   int x=3;
   int y=4;
   change(3,4);
   System.out.println("x="+x+","+"y="+y);
   */
   int[] num=new int[]{3,4};
   change(num);
   System.out.println("x="+num[0]+","+"y="+num[1]);
  
   Point pt=new Point();
   pt.x=3;
   pt.y=4;
   change(pt);
   System.out.println("x="+pt.x+","+"y="+pt.y); 
 }
class Point
{
 int x,y;
}
再看看引用类型的内存变化图:
以上说明了在Java中函数的调用:
a> 在Java中，传参时，都是以传值的方式进行。
b> 对于基本数据类型，传递的是数据的拷贝，对于引用类型，传递的是引用(首地址)的拷贝。

^^^^^^^^^^^^^^^对象的克隆^^^^^^^^^^^^^
1> 为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
2> 在派生类中覆盖基类的clone()，并声明为public。
3> 在派生类的clone()方法中，调用super.clone()。
4> 在派生类中实现Cloneable接口。
4> 没有抽象方法的接口叫标识接口。
5> 为什么我们在派生类中覆盖Object的clone()方法时,一定要调用super.clone()呢?在运行时刻,Object 的clone()方法能识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原 始对象的内容一一复制到新的对象空间去。

* 浅克隆是针对没有引用类型的变量来克隆。针对引用类型的克隆应该用Deeply Clone。
浅克隆:
Code:
class FleetClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="feifei";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}
改变学生s2的教授信息，打印s1教授信息,结果为:name=feifei,age=30.产生这个结果是因为String是一个常量类型.
 
深克隆
code:
class DeeplyClone
{
 public static void main(String[] args)
 {
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="Bill.Gates";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
 }
}
class Professor implements Cloneable
{
 String name;
 int age;
 Professor(String name,int age)
 {
  this.name=name;
  this.age=age;
 }
 public Object clone()
 {
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
 }
}

class Student implements Cloneable
{
 Professor p;
 String name;
 int age;
 Student(String name, int age,Professor p)
 {
  this.name=name;
  this.age=age;
  this.p=p;
 }
 public Object clone()
 {
  //Object o=null;
  Student o=null;
  try
  {
   o=(Student)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  o.p=(Professor)p.clone();
  return o;
 }
}
打印结果为:name=Bill.Gates,age=30,这就是深克隆.

Java数组的相关操作

1> 在Java中所有的数组都有一个缺省的属性length，用于获取数组元素的个数。
2> 数组的复制: System.arraycopy()。
3> 数组的排序: Arrays.sort()。
4> 在已排序的数组中查找某个元素：Arrays.binarySearch()。
具体的看看下面的2个例子:
code1:
class ArrayTest
{
 public static void main(String[] args)
 {
  /*数组的copy
  int[] num1=new int[]{1,2,3};
  int[] num2=new int[3];
  System.arraycopy(num1,0,num2,0,num1.length);
  for(int i=0;i<num2.length;i++)
  {
   System.out.println(num2[i]);
  }
  */
  //引用类型的数组copy
  Point[] pts1=new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
  Point[] pts2=new Point[3];
  System.arraycopy(pts1,0,pts2,0,pts1.length);
  for(int i=0;i<pts2.length;i++)
  {
   System.out.println("x="+pts2[i].x+","+"y="+pts2[i].y);
  }
  /*
  *因为引用类型传递的是引用的拷贝，所以我们修改pts2数组的第二个点的坐标，
  *当我们打印pts1数组的第一个点的坐标时，它的坐标点已经被修改为(5,5)了
  pts2[1].x=5;
  pts2[1].y=5;
  System.out.println("x="+pts1[1].x+","+"y="+pts1[1].y);
  */
 }
}

class Point
{
 int x, y;
 Point(int x,int y)
 {
  this.x=x;
  this.y=y;
 }
}

code2:
import java.util.*;
class TestArray
{
 public static void main(String[] args)
 {
  /*
  int[] num=new int[]{3,2,1};
  Arrays.sort(num);
  for(int i=0;i<num.length;i++)
  {
   System.out.println(num[i]);
  }
  int index=Arrays.binarySearch(num,3);
  System.out.println("index="+index);
  System.out.println("Element="+num[index]);
  */
  Student[] ss=new Student[]{new Student("zhangshan",1),
                            new Student("lisi",2),
                            new Student("wangwu",3),
                            new Student("mybole",3)};
   Arrays.sort(ss);
   for(int i=0;i<ss.length;i++)
   {
    System.out.println(ss[i]);
   }
   int index=Arrays.binarySearch(ss,new Student("lisi",2));
   System.out.println("name="+ss[index].name+","+"index="+index);
 }
}

class Student implements Comparable
{
 String name;
 int num;
 Student(String name,int num)
 {
  this.name=name;
  this.num=num;
 }
 public String toString()
 {
  return "name="+name+","+"number="+num;
 }
 public int compareTo(Object o)  //对于Object[]排序要求实现Comparable接口
 {
  Student s=(Student)o;
  //return num>s.num ? 1 :(num==s.num ? 0 : -1);
  int result=num>s.num ? 1 :(num==s.num ? 0 : -1);//按名字排序
  if(0==result)
  {
   result=name.compareTo(s.name);
  }
  return result;
 }
}

理解继承是理解面向对象程序设计的关键.在Java中,通过关键字extends继承一个已有的类,被继承的类称为父类(超类，基类),新的类称为子类(派生类).在Java中不允许多继承.code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 
}
class DoMain
{
 public static void main(String[] args)
 {
  Animal an=new Animal();
  Fish fn=new Fish();
 
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
Result:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Animal breathe!
(这说明派生类继承了父类的所有方法和成员变量.)

方法的覆盖(override)
在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法,称为方法的覆盖,方法的覆盖发生在子类与父类之间.
code:
class Animal
{
 int height,weight;
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}
class Fish extends Animal
{
 int weight,height;   //隐藏了父类的weight,height;
 void breathe()  //override method breathe()
 {
  super.breathe();  //用super调用父类的构造方法
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
 // Animal an=new Animal();
  Fish fn=new Fish();
 
  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Fish bubble

特殊变量super
* 使用特殊变量super提供对父类的访问
* 可以使用super访问父类被子类隐藏的变量或覆盖的方法
* 每个子类构造方法的第一条语句都是隐含的调用super,如果父类没有这种形式的构造函数就会报错.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fn=new Fish();
 
  //an.breathe();
  //fn.breathe();
  //fn.height=30;
  //fn.weight=20;
 }
}
输出结果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal construct
Fish construct



 通过覆盖父类的方法来实现,在运行时根据传递对象的引用,来调用相应的方法.
code:
class Animal
{
 int height,weight;
 Animal()
 {
  System.out.println("Animal construct");
 }
 void eat()
 {
  System.out.println("Animal eat!");
 }
 void sleep()
 {
  System.out.println("Animal sleep!");
 }
 void breathe()
 {
  System.out.println("Animal breathe!");
 }
}

class Fish extends Animal
{
 Fish()
 {
  System.out.println("Fish construct");
 }
 void breathe()  //override method breathe()
 {
  System.out.println("Fish bubble");
 }
}
class DoMain
{
 static void fn(Animal an)
 {
  an.breathe();
 }
 public static void main(String[] args)
 {
  //Animal an=new Animal();
  Fish fh=new Fish();
  Animal an;
  an=fh;
  DoMain.fn(an);
 }
}