编程思想第七章

重载：相同的返回值，相同的函数名称，不同的参数列表。
 @Override注解是JDK1.5之后的产物，可以防止你在不想重载时而意外的进行重载
 //因为父类没有这个重载方法，所以不能用这个注解
7.1复用代码的三种方式：

1，直接new关键字创建该类对象，组合；优点：快速方便；缺点：生成和销毁对象，给性能带来额外开销。
2，继承该类；优点：通用，把大量常用的函数集合到一起，减少其他类的重复代码；缺点：其他类与基类类型不同，违反了一类事物的特点。比如鸟类，继承飞机，只为了实现一个飞行功能，这明显不符合一类事物特征的继承规则。
3，代理：内置该类的对象，重写方法，底层调用对象的方法实现。
组合：既不是is-a的关系，也不是like-a的关系；单纯想调用其他已有类的功能，如无特殊需要，建议该对象私有化；
继承：is-a的关系；狗属于动物；统属于一个类型；
  接口：like-a的关系；飞机在天上像一只大鸟；局部功能相同

public class Car {
	Engine e = new Engine();
	Wheel[] w =new Wheel[4];
	
	public Door left = new Door(),right = new Door();
	public Car(){
		for (int i = 0; i < 4; i++) {
			w[i] = new Wheel();	
		}
	}
	
	public static void main(String[] args) {
		Car car = new Car();
		car.left.w.rollup();
		car.w[0].inflate(72);
	}
}
class Engine{
	public void start(){}
	public void rev(){}
	public void stop(){}
}
class Wheel{
	public void inflate(int psi){
		System.out.println(psi);
	}
}
class Window{
	public void rollup(){}
	public void reilldown(){}
}
class Door{
	public Window w = new Window();  //组合
	public void open(){}
	public void close(){}

7.6protected关键字

既想对外部隐藏，又允许子类访问的时候，该关键字就起作用。

继承：当重写了基类的方法实现时，就不会执行基类的方法，而执行导出类重写的方法。反之，执行基类的方法。无论如何，当用到导出类时，基类都会调用构造器的方法执行初始化。

7.8 final关键字  “无法改变的”，主要出于两种原因：设计或效率。注意：static只强调一份；

public class FinalDate {
	
	private static Random rand= new Random(47);
	private String id;
	public FinalDate(String id){this.id = id;}
	
	//由于都是基本数据类型，都可以当常量使用，而第三个是典型的常量定义方式
	public  final int VALUE_ONE = 9;
	public static final int VALUE_TWO = 99;
	public static final int VALUE_THREE = 39;
	
//	System.out.println(rand.nextInt(20)); //15   
//	也就是final修饰的基本类型，当被对象引用的时候，是可以改变的，而static只有一个，并且只加载一次
	private final int i4 = rand.nextInt(20);
	static final int INT_5 =rand.nextInt(20);
	
	private   Value v1 = new Value(11);  //对象的引用可以改变
	private  final Value v2 = new Value(22);
	private static final Value VAL_3 = new Value(33);
	
	private final int[]a = {1,2,3,4,5,6};
	@Override
	public String toString() {
		return  id + ": i4=" + i4 + ", INT_5=" + INT_5 + "]";
	}
	public static void main(String[] args) {
		

		FinalDate fd1 = new FinalDate("fd1");
		System.out.println(fd1.v2.i);
		fd1.v2.i++;
		fd1.v1= new Value(9);
		for (int i = 0; i < fd1.a.length; i++) {
			fd1.a[i]++;
			
		}
//		System.out.println(fd1);
//		System.out.println("创建一个新的对象");
		FinalDate fd2 = new FinalDate("fd2");
//		System.out.println(fd1);
//		System.out.println(fd2);
		FinalDate fd3 = new FinalDate("fd3");
//		System.out.println(fd1);
//		System.out.println(fd2);
//		System.out.println(fd3);
		
	}
	
}

final作用于基本类型相对于对象引用来说，用处更大。

final 数据：常量，定义一块数据，是不变的。通常是基本数据类型；表示参数可以读取，但是不能修改，主要用来向匿名内部类传递数据。

final 方法：两个目的，1，禁止被子类覆盖重写此方法；2.为了效率，声明为final后，就不会插入这段代码而是直接调用方法，这将消除方法调用的开销，不过最近的JDK已经优化了，不需要为了效率，而使用final方法。

final 类：当类整体定义为final时，该类的所有方法都隐式的为final，为了禁止别的类继承。不需要做任何变动，出于安全考虑。

继承：访问一个类，当发现extends 继承关键字的时候，不管是否创建该类的对象，都将对它的基类进行加载。加载动作只执行一次，并且对基类静态成员的访问，也都有可能引起加载。就算不访问，也会加载基类的静态访问。

package com.jicheng.test;

public class Beetle extends Insect {
	private int k = printInint("Beetle +静态初始化");
	Beetle(){
		System.out.println("k = "+k);
		System.out.println("j = "+j);
	}
	private static int x2 = printInint("x2 + +静态初始化");
	public static void main(String[] args) {
		System.out.println("Beetle 构造器");
//		int b1 = Insect.i;  
//		Beetle b1 = new Beetle();
	}
}
class Insect{
	static int i = 9;
	protected  int j;
	Insect(){
		System.out.println("============i= "+i+" j= "+j);
		j=39;
	}
	private static int x1 = printInint("x1 + 静态初始化");
	static int printInint(String s){
		System.out.println(s);
		return 47;
	}
}  /**out   x1 + 静态初始化
            x2 + +静态初始化
            Beetle 构造器

package com.meiju;

public class EnumOrder {
	public static void main(String[] args) {
		for (Spiciness s : Spiciness.values()) {
			System.out.println(s+ ".ordinal "+ s.ordinal() );
		}
	}
}

枚举：当我们需要群组并使用时，首先创建一个整型常量集，但是枚举取值不会限制在常量集范围内。

package com.meiju;

public class SpicinessEnumUser {
	public static void main(String[] args) {
		Spiciness howHot = Spiciness.MEDIUM;
		System.out.println(howHot);
	}
}

package com.meiju;

public class EnumOrder {
	public static void main(String[] args) {
		for (Spiciness s : Spiciness.values()) {
			System.out.println(s+ ".ordinal "+ s.ordinal() );
		}
	}
}

package com.meiju;

public class Burrito {
	Spiciness degree;
	Burrito (Spiciness degree ){
		this.degree = degree;
	}
	public void describe(){
		System.out.print("This burrito is ");
		switch(degree){
			case NOT: 
				System.out.println("not spicy at all");
				break;
			case MILD: 
				System.out.println("a little not");
				break;
			case MEDIUM: 
				System.out.println("maybe too hot");
				break;
			case HOT: 
			case FLAMING: 
			default:	System.out.println("maybe too hot");
		}
	}
	public static void main(String[] args) {
		Burrito 
			plain = new Burrito(Spiciness.NOT),
			greenChile = new Burrito(Spiciness.MEDIUM),
			jalapeno = new Burrito(Spiciness.HOT);
		plain.describe();
		greenChile.describe();
		jalapeno.describe();
	}
}

可以应用于switch中。