首页 > 代码库 > Java 4
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
Java 4