标签：
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
标签：
原文地址：http://www.cnblogs.com/KennyRom/p/5932970.html
