Java 4

1、继承的问题

子类是父类的一个扩展，子类可以利用父类的属性与行为，这种情况子类会破坏父类的封装

为了保持父类良好的封装性，设计父类有以下规则：

如果要把某类设计为最终类则需要添加final修饰符，或将此类的构造器声明为private

2、利用组合实现复用

组合就是把旧类的对象当做新类的属性嵌入，并用private修饰

public class Animals
{
	public Animals()
	{
		System.out.println("Animals");
	}
    public void breathe()
    {
	    System.out.println("ha-hu");
    }
}

public class Wolf
{
	private Animals a;
	public Wolf(Animals a)
	{
		this.a=a;
	}
	public void run()
	{
		System.out.println("run");
	}

	public static void main(String[]args)
	{
		Animals b=new Animals();
		Wolf a=new Wolf(b);
		a.run();
	}
}

3、初始化块

前面定义的初始化块先执行，后面的后执行

syntax：

[修饰符]{
    //...
}

只能使用sattic修饰，称作静态初始化块

当创建一个对象是先调用初始化块

静态初始化块对整个类进行初始化

系统会首先执行静态初始化块，并会一直回溯到基类再一步一步执行静态初始化，再执行其他

4、基本数据类型的包装类

为什么要用包装类？

解决8个基本类型变量不能变成Object类型变量的问题，为8个基本类型变量定义了应用类型的包装类。

JDK1.5后提供了自动装箱与自动拆箱，就可以直接来了，不用这么复杂了

基本类型变量与字符串之间的转换关系

5、toString

toString 是Object 类定义的一个方法，用以描述对象的状态信息

返回值：对象类的实现类名+@+hashCode

可以依据实际情况重写toString

6、==与equals

==比较是一种基本类型的比较符，当要对引用类型进行比较时，比较的是是否指向同一个对象，不是值相等

要实现值相等的比较，就要重写equals

Object提供的equals与==是一样的，没有用的，一定要重写

重写后有规定：

1）自反性；

2）传递性；

3）对称性；

4）一致性。

Example:

public boolean equals(Object obj)
{
	if(this==obj)
		return true;
	if(obj!=null&&obj.getClass()==SomeClass.class)
    {
		SomeClass sc=(SomeClass)obj;
		if(compare)
			return true;
	}
     return false;
}

7、类成员

类中只能包含属性、方法、构造器、初始化块、内部类、枚举类

static不修饰构造器

类成员不能访问实例成员

8、单例类Singleton

一个类只能创建一个实例

把构造器用private修饰

需要一个public方法作为这个类的访问点，同时要将其定义为static

该类还需缓存已创建的对象

class Singleton
{
	//使用一个变量来缓存曾经创建的实例
	private static Singleton instance;
	//隐藏构造器
	private Singleton(){}
	//提供一个静态方法，用于返回Singleton实例
	//可加入自定义的控制，保证只产生一个Singleton
    public static Singleton getInstance()
	{
		if(instance==null)
		{
			instance=new Singleton();
		}
	    return instance;
	}
}

9、final

final修饰的变量赋值后不可改变

final修饰的成员变量必须在类中赋初值

类属性：在静态初始化块中、在声明该属性时指定初始值

实例属性：在非静态初始化块、声明属性、构造器中指定初始值

系统不会对final修饰成员进行隐式初始化

final修饰的引用变量只是保证它所指向的地址不改变，而该引用的内容是可以改变的

final修饰的方法不可被重写，但可以重载

final修饰的类不可继承

10、不可变类

创建该类的实例后，实例的属性不可改变

8个包装类、java.lang.String都是不可变类

hashcode返回的是对象地址

final修饰的引用类型变量不符合不可变，那么我们在设计类的时候必须将此变量保护起来。

11、缓存实例的不可变类

如果程序需要经常使用某些实例，则应把其缓存

Example:

利用数组作为缓存池

public class CacheImmutale
{
 private final String name;
 private static CacheImmutale[]a=new CacheImmutale[10];
 private static int pos=0;
 public CacheImmutale(String name)
 {
	this.name=name;
 }
 public String getName()
 {
	return name;
 }

 //利用valueOf创建对象，而不用构造器
 public static CacheImmutale valueOf(String name)
 {
	for(int i=0;i<10;i++)
	{
		if(a[i]!=null&&a[i].getName().equals(name))
			return a[i];
	}
     if(pos==10)
	 {
		 a[0]=new CacheImmutale(name);
		 pos=1;
		 return a[0];
	 }
	 else
	 {
		a[pos++]=new CacheImmutale(name);
        return a[pos-1];
	 }
 }

 //重写equals
 public boolean equals(Object obj)
 {
	if(obj instanceof CacheImmutale)
	{
		CacheImmutale aa=(CacheImmutale)obj;
		if(name.equals(aa.getName()))
		{
			return true;
		}
	     return false;
	}
 }

 //重写hashCode
 public int hashCode()
 {
	return name.hashCode();
 }
}

12、抽象类

抽象方法与抽象类的规则：

利用抽象类就是利用一种模板模式

抽象父类中提供多个子类的通用方法，子类再进行具体的实现补充。

13、接口

接口中所有的方法都是抽象方法

接口规定类中应具体提供的方法，但不管具体实现

syntax:

[修饰符] interface  Name extends 父接口1, 父接口2...
{

}

接口中可以包含属性（只能是常量），方法（只能是抽象实例），内部类（包括内部接口）和枚举类的定义

只能是public 、static、final（系统默认）

方法、内部类、枚举类 自动用public static 修饰

使用接口：

类必须实现接口内的所有方法，只能用public

模拟多继承

interface and abstract class