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