1.Java数据类型
❶不可变类，是指当创建了这个类的实例后，就不允许修改它的属性值。 它包括： Primitive变量：boolean,byte, char, double ,float, integer, long, short JDK不可变类：Boolean, Byte, Character, Double, Float, Integer, Long, Short, String （java.lang包中） ❷可变类，是当你获得这个类的一个实例引用时，你可以改变这个实例的内容。 可变类对象间用“=”赋值，则会是使两个对象实际上会引用同一个实例。所以，只有实现深度clone才能使可变类对象的修改不影响原始对象的值。
❸对于不可变类，可变类的特性也有意义，有的时候我们不希望重复创建相同的内容的实例。因此，我们也可以利用不可变类获得实例缓存。如：
Integer a=Integer.valueOf(10);
Integer b= Integer.valueOf(10);
只会在第一次创建取值为10的Integer对象。也就是说a和b指向同一处内存上的内容。
2.抽象类
❶继承层次结构中。父类通用而不明确，子类越来越明确和具体。接口是定义多个类的共同行为。
❷抽象关键字abstract，位置紧随访问修饰符(public,protected,private)之后。
❸抽象类的构造函数一律定义为protected。抽象方法只有定义没有实现(一般定义为public，且抽象方法禁止定义为静态方法)。
❹包含抽象方法的类必须定义为抽象类。抽象类不一定需要包含抽象方法。
❺若子类没有实现父类的抽象方法。子类仍需要定义为抽象类。即，抽象类派生出的非抽象子类，必须实现所有基类的抽象方法，即使它没有使用
❺父类为具体类，子类可以是抽象类。子类可以覆盖父类的方法并将其定义为抽象方法，当然前提是子类定义为抽象类。
❻new无法作用抽象类创建实例，但是可以作为一种数据类型，创建引用变量（或者引用数组），然后指向子类对象。当然其引用类型也可以作为函数参数。
如下定义抽象类Gobject。定义两个扩展类圆Circle和长方形rectangle。定义抽象方法getArea()返回面积
package GeometricObject;
public abstract class Gobject {
private String color="white";
private boolean filled;
private java.util.Date dateCreated;//时间类
//构造函数必须定义protected
protected Gobject()
{dateCreated=new java.util.Date();}
protected Gobject(String s,boolean f)
{this();
filled=f;color=s;}
public String toString()
{return "Created on:"+dateCreated+"
color:"+color+"
filled with?--"+filled;}
public void setColor(final String s){color=s;}
public String getColor(){return color;}
public abstract double getArea();//抽象方法
}
//圆类
class Circle extends Gobject implements Comparable,Cloneable{
double radius;
final static double PI=3.1415;
Circle()
{radius=1.0;}//隐含调用super();
Circle(double r,String s,boolean f){
super(s,f);//调用父类构造函数
radius=r;
}
public String toString()
{return super.toString()+"
Area--"+getArea();}
}
//长方形类
class rectangle extends Gobject implements Comparable,Cloneable{//常用方法，从虚函数中扩展
double width,height;
rectangle ()
{width=height=1.0;}//隐含调用super();
rectangle(double w,double h,String s,boolean f)
{super(s,f);//调用父类构造函数
width=w;height=h;}
public double getArea()
{return width*height;}
}
public class test {
public static void main(String[] args)
{
Gobject[] p=new Gobject[2];//抽象类作为数据类型定义数组
p[0]=new Circle(2.3,"Blue",true);
p[1]=new rectangle(4.0,5.0,"Red",false);
System.out.println(p[0].toString());
System.out.println(p[1].toString());
System.out.println("The two Object have "+equalArea(p[0],p[1])+" area");
public static String equalArea(Gobject o1,Gobject o2)//抽象类引用类型作为函数参数
{
if(o1.getArea()==o2.getArea())//JVM动态调用实例的函数
return "same";
else
return "different";
}
}
3.接口
❶类似于类，目的是指明多个对象的共同行为。❷接口类似于抽象类。编译为单独的字节码文件。不能使用new创建实例，但是可以声明引用变量或者作为类型转换的结果。
❸接口仅仅包括常量和抽象方法或者完全为空(所谓的标记接口maker interface)。即所有的方法默认都是public abstract,所有的变量都是public final static<
❹接口类定义的常量可以使用“接口名.变量名”访问。
4.可比较接口 Comparable
❶Java中的许多类，比如String和Data实现(implements)了Comparable接口,以比较自然对象的大小。
❷接口引用变量可作函数参数类型和返回类型。声明如下：
public interface Comparable //比较接口
{int comparaTo(Object o);//判断当前对象与目标对象的大小}
定义的通用求最大值的Max函数如下：
//通用的求最大值的类
//接口引用作为函数参数和返回参数，此时类似虚函数
public class Max {
public static Comparable max(Comparable a,Comparable b)
{
if(a.comparaTo(b)>0)//调用具体的比较函数
return a;
else
return b;
}
}
Circle和rectangle分别实现了该接口，即继承了接口的抽象方法，并具体实现。如下：
class Circle extends Gobject implements Comparable,Cloneable{
......................
public int comparaTo(Object o){//继承并且实现camparaTo函数
if(getArea()>((Gobject)o).getArea())//显式转换
return 1;
else if(getArea()<((Gobject)o).getArea())
return -1;
else
return 0;
}
.................
}
class rectangle extends Gobject implements Comparable,Cloneable{//常用方法，从虚函数中扩展
..................
public int comparaTo(Object o){//继承并且实现camparaTo函数
if(getArea()>((Gobject)o).getArea())
return 1;
else if(getArea()<((Gobject)o).getArea())
return -1;
else
return 0;
}
.....................
}
利用Max求两个圆或者两个长方体最大的面积的代码片段为
//Comparable 接口
//使用通用的Max类，比较任意扩展了comparable的对象
Circle[] cp=new Circle[2];
cp[0]=new Circle(1.56,"Blue",true);
cp[1]=new Circle(3.45,"Green",false);
Comparable max=Max.max(cp[0], cp[1]);//接口类型引用
System.out.println("The max Area of 2 Circle is "+((Circle)max).getArea());//显式转换
rectangle[] rp=new rectangle[2];
rp[0]=new rectangle(1.56,12.0,"Blue",true);
rp[1]=new rectangle(3.45,6.7,"Green",false);
Comparable max1=Max.max(rp[0], rp[1]);//接口类型引用
System.out.println("The max Area of 2 rectangle is "+((rectangle)max1).getArea());//显式转换 由于max输出的类型为Comparable类型，所以调用Circle或者rectangle的getArea()函数必须显式转换。
5.可克隆接口 Cloneable
❶该接口为标记接口，即无常量和方法。标记用来表示类拥有某种属性。定义如下：
public interface Cloneable
{}
❷对于可复制的类，必须满足： 实现Cloneable接口。这样才有资格调用Object.clone()方法 覆盖Object的clone()方法。Object.clone()方法是protected的，覆盖并改为public
❸Object的clone的行为是最简单的。以堆上的内存存储解释的话（不计内存），对一个对象a的clone就是在堆上分配一个和a在堆上所占存储空间一样大的一块地方，然后把a的堆内存的内容按位(bit-wise)复制到这个新分配的内存。
❹Primitive数据类型(如int,double)为深拷贝，引用类型(包括可变类和不可变类)均为浅拷贝，浅拷贝指拷贝前后引用变量指向同一对象。深拷贝或者克隆的目的在数据前后隔离，默认的浅copy不是隔离的——即改变copy的东西，会影响到原型的内部。
❺改变拷贝对象的Primitive数据值或者不可变类引用变量（如String）的指向对象，不影响源对象的对应数据，即满足数据隔离。前者的原因显而易见，后者的原因是因为---不可变类不能通过【对象名+"."方法(数据)】改变数据域，只能通过将其指向其他对象改变其数据域，如此一来，肯定不影响。具体点击
对于前面定义的Circle，rectangle类，实现Coloneable接口如下：
class Circle extends Gobject implements Comparable,Cloneable{
......................
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
......................
}
//长方形类
class rectangle extends Gobject implements Comparable,Cloneable{//常用方法，从虚函数中扩展
.......................
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
.......................
} 注意：
①由于返回的为Object，可能需要显式转换。
②使用super.clone()而非this.clone()的原因。Object中的clone执行的时候使用了RTTI（run-time type identification）的机制,动态得找到目前正在调用clone方法的reference，根据它的大小申请内存空间，然后进行bitwise的复制，将该对象的内存空间完全复制到新的空间中去，从而达到shallowcopy的目的。所以调用super.clone() 得到的是当前调用类的副本，而不是父类的副本。根本没有必用调用this.clone()
③如果需要克隆的类引用到了其它的类的对象，甚至这个对象也引用到了别的对象，那么在必要情况下，你需要将这个对象树进行完整的克隆。如下：
class User implements Cloneable {
String name;
int age;
@Override
public User clone() throws CloneNotSupportedException {
return (User) super.clone();
}
}
class Account implements Cloneable {
User user;
long balance;
@Override
public Account clone() throws CloneNotSupportedException {
Account account = (Account) super.clone();
if (user != null) {
account.user = user.clone();//显式深拷贝
}
return account;
}
}
6.抽象类和接口的比较
❶变量：抽象类无限制；接口必须为public static final ❷构造方法：抽象类子类经过构造链调用构造法。接口无构造方法。两者均不能用new实例化 ❸方法：抽象类无限制；接口必须是public abstract ❹抽象类只能(被)单一扩展；类可以同时实现多重接口，接口同时可以同时继承多重接口而不是类。 ❺所有类有公共根Object；而所有接口没有公共接口。 ❻两者均可以定义类型，且引用变量可以引用---任何实现了接口(或抽象类)的对象。