Day_10 static关键字与多态

一.static关键字
1.定义：用于修饰成员变量和成员方法。
2.特点：
<1>随着类的加载而加载，优先于对象加载。
<2>只加载一次就会一直存在，不再开辟新的空间。
<3>全局唯一，全局共享。
<4>可以直接被类名调用。
<5>静态只能调用静态，非静态可以随意调用。
<6>static不能和super或者this共用，因为有static的时候可能还没有对象。

二.入门案例

public class Static {

	public static void main(String[] args) {
		
		/*int i = Student.age;//优先于对象加载，有没有对象都有static。
		System.out.println(i);*/
		
		Student s = new Student();
		
		System.out.println(s.name);
		System.out.println(s.age);
		
		s.speak();
		s.eat();

	}

}

class Student{
	
	String name = "Yan Dexuan";
	static int age = 20;
	
	public static void speak() {
		
		System.out.println("说话");
		
	}
	
	public void eat() {
		
		System.out.println("吃饭");
		
	}
	
}

三.静态调用关系

public class Static_Relationship {

	public static void main(String[] args) {
		
		Teacher t = new Teacher();
		
		t.speak();

	}

}

class Teacher{
	
	static int age = 30;
	String name = "Yan Dexuan";
	
	//非静态测试，非静态能够调用静态方法。
	public void speak() {
		
		System.out.println(age);
		System.out.println(name);
		qiao();
	}
	
	//静态测试，静态能调用静态。
	public static void qiao() {
		
		System.out.println(age);
		//System.out.println(name);静态无法调用非静态。
		//speak();
	}
	
}

四.静态代码块
1.随着类的加载而加载，并且只被加载一次，一般情况下用于项目的初始化。static{…}。
2.静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化。
3.构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用。
4.静态代码块：static{…}，位于类里方法外。
5.执行顺序：静态-构造代码块-构造-局部代码块。

五.代码执行顺序

public class Static_Block {

	public static void main(String[] args) {
		
		Car c = new Car();
		c.show();
		
	}

}

class Car{
	
	//1.静态代码块。
	static{
		System.out.println("静态代码块");
	}
	
	//2.构造代码块。
	{
		System.out.println("构造代码块1");
	}
	
	//3.构造方法。
	public Car() {
		System.out.println("构造方法");
	}
	
	//4.局部代码块。
	public void show() {
		
		{
		System.out.println("构造代码块2");
		}
		
		System.out.println("局部代码块1");
		System.out.println("局部代码块2");
		
	}
	
}

六.final关键字
1.定义：final用于修饰类，方法以及成员变量。
2.特点：
<1>被final修饰的类，不能被继承。
<2>被final修饰的方法，不能被重写。
<3>被final修饰的变量是个常量，值不能被更改。
<4>常量的定义形式：final 数据类型 常量名 = 值。

七.final入门案例

public class Final {

	public static void main(String[] args) {
		
		Son s = new Son();
		
		s.speak();
		
		System.out.println(s.name);
		
		s.test();
		

	}

}

class Father{
	
	final String name = "Yan Dexuan";
	
	public final void speak() {
		
	   System.out.println("说话");
		
	}
	
}

class Son extends Father{
	
	//被final的方法，不能被重写。
	/*public void speak() {
		
		System.out.println("说什么");
		
	}*/
	
	public void test() {
		
		//super.name = "Yan";
		//被final的变量，不能被重新赋值。
		System.out.println(super.name);
		
	}
	
}

八.多态
1.定义：多态指同一个实体同时具有多种形式，他是面向对象程序设计的一个重要特征。主要是指同一个对象，在不同的时刻，代表的对象不一样，指的是对象的多种形态。

2.优点：
<1>可以吧不同的子类对象都当做父类来看，可以屏蔽不同子类对象之间的差异，写出通用的的代码，作出通用的变成，统一调用标准。例如，水在不同时刻可以有多种形态，包括水蒸气，冰以及水。Java体现多态，比如，狗有两种形态，狗和小动物。
<2>多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
<3>提高了程序的拓展性和可维护性。

3.特点：
<1>多态的前提是继承。
<2>要有方法的重写。
<3>父类引用指向子类对象，例如：Animal a =new Dog()；从小到大，向上转型。
<4>多态种，编译看左边，运行看右边。
<5>成员变量：使用的是父类的。
<6>成员方法：使用的是子类的。
<7>静态成员：随着对象而存在，谁调用就返回谁。

九.多态入门案例

public class Polymorphism {

	public static void main(String[] args) {
		
		Animal a = new Dog();//父类引用指向子类对象，把右边的小的给左边的大的。
		a.eat();//只能使用父类的功能，这样就统一了调用的标准。

	}

}

class Animal{
	
	public void eat() {
		
		System.out.println("动物吃饭");
		
	}
	
}

class Dog extends Animal{
	
	public void kanjia() {
		
		System.out.println("看家");
		
	}
	
	public void eat() {
		
		System.out.println("吃骨头");//发生重写，所以父类的方法被覆盖了。
		
	}
	
}

十.多态的使用

public class Polymorphism_Use {

	public static void main(String[] args) {
		
		Mother m = new Son3();
		
		System.out.println(m.number);//成员变量，使用的是父类的。
		
		m.study();//成员方法，使用的是子类的。
		
		System.out.println(Son3.count);//静态成员，谁调用就是谁的。
		m.sleep();
		
		System.out.println();

	}

}

class Mother{
	
	int number = 10;
	
	static int count = 100;
	
	public void study() {
		
		System.out.println("妈妈学习");
		
	}
	
	public static void sleep() {
		
		System.out.println("儿子睡觉");
		
	}
	
}

class Son3 extends Mother{
	
	int number = 20;
	
	static int count = 200;
	
	public void study() {
		
		System.out.println("儿子学习");
		
	}
	
	public static void sleep() {

		System.out.println("儿子睡觉");
	}
	
}

十一.执行顺序：静态代码块—构造代码块—构造函数

public class Comparation {

	public static void main(String[] args) {
		
		Block b = new Block();
		
		System.out.println();
		
		Block b2 = new Block();//静态代码只会被执行一次，就是在类第一次初始化时。
		

	}

}

class Block{
	
	{
		System.out.println("构造代码块1");
	}
	
	static {
		System.out.println("静态代码块1");
	}
	
	public Block(){
		
		{
			System.out.println("局部代码块1");
		}
		
	}
	
	{
		System.out.println("构造代码块2");
	}
	
	static {
		System.out.println("静态代码块2");
	}
	
}

十二.静态变量和实例变量的区别
1.在语法定义上的区别：静态变量之前要加static关键字，而实例变量不用加。

2.在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。而静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

http://www.cnblogs.com/xdp-gacl/p/3644035.html

一、面向对象最核心的机制——动态绑定，也叫多态

1.1.通过下面的例子理解动态绑定，即多态

  1 package javastudy.summary;
  2 
  3 class Animal {
  4     /**
  5      * 声明一个私有的成员变量name。
  6      */
  7     private String name;
  8 
  9     /**
 10      * 在Animal类自定义的构造方法
 11      * @param name
 12      */
 13     Animal(String name) {
 14         this.name = name;
 15     }
 16 
 17     /**
 18      * 在Animal类里面自定义一个方法enjoy
 19      */
 20     public void enjoy() {
 21         System.out.println("动物的叫声……");
 22     }
 23 }
 24 
 25 /**
 26  * 子类Cat从父类Animal继承下来，Cat类拥有了Animal类所有的属性和方法。
 27  * @author gacl
 28  *
 29  */
 30 class Cat extends Animal {
 31     /**
 32      * 在子类Cat里面定义自己的私有成员变量
 33      */
 34     private String eyesColor;
 35 
 36     /**
 37      * 在子类Cat里面定义Cat类的构造方法
 38      * @param n
 39      * @param c
 40      */
 41     Cat(String n, String c) {
 42         /**
 43          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
 44          * 把子类对象里面的父类对象先造出来。
 45          */
 46         super(n);
 47         eyesColor = c;
 48     }
 49 
 50     /**
 51      * 子类Cat对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。
 52      */
 53     public void enjoy() {
 54         System.out.println("我养的猫高兴地叫了一声……");
 55     }
 56 }
 57 
 58 /**
 59  * 子类Dog从父类Animal继承下来，Dog类拥有了Animal类所有的属性和方法。
 60  * @author gacl
 61  *
 62  */
 63 class Dog extends Animal {
 64     /**
 65      * 在子类Dog里面定义自己的私有成员变量
 66      */
 67     private String furColor;
 68 
 69     /**
 70      * 在子类Dog里面定义Dog类的构造方法
 71      * @param n
 72      * @param c
 73      */
 74     Dog(String n, String c) {
 75         /**
 76          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
 77          * 把子类对象里面的父类对象先造出来。
 78          */
 79         super(n);
 80         furColor = c;
 81     }
 82 
 83     /**
 84      * 子类Dog对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。
 85      */
 86     public void enjoy() {
 87         System.out.println("我养的狗高兴地叫了一声……");
 88     }
 89 }
 90 
 91 /**
 92  * 子类Bird从父类Animal继承下来，Bird类拥有Animal类所有的属性和方法
 93  * @author gacl
 94  *
 95  */
 96 class Bird extends Animal {
 97     /**
 98      * 在子类Bird里面定义Bird类的构造方法
 99      */
100     Bird() {
101         /**
102          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
103          * 把子类对象里面的父类对象先造出来。
104          */
105         super("bird");
106     }
107 
108     /**
109      * 子类Bird对从父类Animal继承下来的enjoy方法不满意，在这里重写了enjoy方法。
110      */
111     public void enjoy() {
112         System.out.println("我养的鸟高兴地叫了一声……");
113     }
114 }
115 
116 /**
117  * 定义一个类Lady(女士)
118  * @author gacl
119  *
120  */
121 class Lady {
122     /**
123      * 定义Lady类的私有成员变量name和pet
124      */
125     private String name;
126     private Animal pet;
127 
128     /**
129      * 在Lady类里面定义自己的构造方法Lady()，
130      * 这个构造方法有两个参数，分别为String类型的name和Animal类型的pet，
131      * 这里的第二个参数设置成Animal类型可以给我们的程序带来最大的灵活性，
132      * 因为作为养宠物来说，可以养猫，养狗，养鸟，只要是你喜欢的都可以养，
133      * 因此把它设置为父类对象的引用最为灵活。
134      * 因为这个Animal类型的参数是父类对象的引用类型，因此当我们传参数的时候，
135      * 可以把这个父类的子类对象传过去，即传Dog、Cat和Bird等都可以。
136      * @param name
137      * @param pet
138      */
139     Lady(String name, Animal pet) {
140         this.name = name;
141         this.pet = pet;
142     }
143 
144     /**
145      * 在Lady类里面自定义一个方法myPetEnjoy()
146      * 方法体内是让Lady对象养的宠物自己调用自己的enjoy()方法发出自己的叫声。
147      */
148     public void myPetEnjoy() {
149         pet.enjoy();
150     }
151 }
152 
153 public class TestPolymoph {
154     public static void main(String args[]) {
155         /**
156          * 在堆内存里面new了一只蓝猫对象出来，这个蓝猫对象里面包含有一个父类对象Animal。
157          */
158         Cat c = new Cat("Catname", "blue");
159         /**
160          * 在堆内存里面new了一只黑狗对象出来，这个黑狗对象里面包含有一个父类对象Animal。
161          */
162         Dog d = new Dog("Dogname", "black");
163         /**
164          * 在堆内存里面new了一只小鸟对象出来，这个小鸟对象里面包含有一个父类对象Animal。
165          */
166         Bird b = new Bird();
167 
168         /**
169          * 在堆内存里面new出来3个小姑娘，名字分别是l1，l2，l3。
170          * l1养了一只宠物是c(Cat)，l2养了一只宠物是d(Dog)，l3养了一只宠物是b(Bird)。
171          * 注意：调用Lady类的构造方法时，传递过来的c，d，b是当成Animal来传递的，
172          * 因此使用c，d，b这三个引用对象只能访问父类Animal里面的enjoy()方法。
173          */
174         Lady l1 = new Lady("l1", c);
175         Lady l2 = new Lady("l2", d);
176         Lady l3 = new Lady("l3", b);
177         /**
178          * 这三个小姑娘都调用myPetEnjoy()方法使自己养的宠物高兴地叫起来。
179          */
180         l1.myPetEnjoy();
181         l2.myPetEnjoy();
182         l3.myPetEnjoy();
183     }
184 }

运行结果：

1.2.画内存图理解动态绑定（多态）

　　首先从main方法的第一句话开始分析：

　　　　Cat c = new Cat("Catname","blue");

　　程序执行到这里，栈空间里有一个变量c，c里面装着一系列的值，通过这些值可以找到位于堆内存里面new出来的Cat对象。因此c是Cat对象的一个引用，通过c可以看到这个Cat对象的全部。c指向new出来的Cat对象。在new这个Cat对象的时候，调用了Cat对象的构造方法Cat(String n,String c)，定义如下：

　　　　Cat(String n,String c){

　　　　　　super(n);

　　　　　　eyesColor=c;

　　　　}

　　因此在构造子类对象时首先使用父类对象的引用super调用父类的构造方法Animal(String name),定义如下：

　　　　Animal(String name){

　　　　　　this.name=name;

　　　　}

　　因此会把传过来的字符串“Catname”传递给父类对象的name属性。当Cat(String n,String c)构造方法调用结束后，真真正正在堆内存里面new出了一只Cat，这只Cat里面包含有父类对象Animal，这个Animal对象有自己的属性name，name属性的值为调用父类构造方法时传递过来的字符串Catname。除此之外，这只Cat还有自己的私有成员变量eyesColor，eyesColor属性的属性值为调用子类构造方法时传递过来的字符串blue。所以执行完这句话以后，内存中的布局是栈内存里面有一个引用c，c指向堆内存里面new出来的一只Cat，而这只Cat对象里面又包含有父类对象Animal，Animal对象有自己的属性name，属性值为Catname，Cat除了拥有从Animal类继承下来的name属性外，还拥有一个自己私有的属性eyesColor，属性值为blue。这就是执行完第一句话以后整个内存布局的情况如下图所示：

接着看这句话：Lady l1 = new Lady(“l1”,c);

　　程序执行到这里,首先在栈内存里面多了一个引用变量l1,l1里面装着一个值，通过这个值可以找到在堆内存里面new出来的Lady对象。l1就是这个Lady对象的引用，l1指向Lady对象。在创建Lady对象时，调用Lady类的构造方法：Lady(String name,Animal pet)，其定义如下：

　　Lady(String name,Animal pet){

　　　　this.name=name;

　　　　this.pet=pet;

　　}

　　这个构造方法有两个参数，分别是String类型的name和Animal类型的pet，pet参数是一个父类对象的引用类型，这里把l1和c作为实参传递给了构造方法，接着在构造方法里面执行this.name=name，把传递过来的l1由传给Lady对象的name属性，因此Lady对象的name属性值为l1，这里也把前面new出来的那只Cat的引用c传递给了构造方法里面的参数pet，接着在构造方法里面执行this.pet=pet，pet参数又把c传过来的内容传递给Lady对象的pet属性，因此pet属性的属性值就是可以找到Cat对象的地址，因此Lady对象的pet属性也成为了Cat对象的引用对象了，通过pet里面装着的值是可以找到Cat对象的，因此pet也指向了Cat，但并不是全部指向Cat，pet指向的只是位于Cat对象内部的Animal对象，这是因为在调用构造方法时，是把c当成一个Animal对象的引用传过来的，把c作为一个Animal对象传递给了pet，所以得到的pet也是一个Animal对象的引用，因此这个pet引用指向的只能是位于Cat对象里面的Animal对象。在我pet引用对象眼里，你Cat对象就是一只普通的Animal，访问你的时候只能访问得到你里面的name属性，而你的eyesColor属性我是访问不到的，我能访问到你的name属性，访问的是位于你内部里面的父对象的name属性，因为我pet引用本身就是一个父类对象的引用，因此我可以访问父类对象的全部属性，而你子类对象Cat自己新增加的成员我pet引用是访问不了的。不过现在我pet引用不去访问你父类对象的成员变量name了，而是去访问你的成员方法enjoy了。首先是使用Lady对象的引用l1去调用Lady对象的myPetEnjoy()方法，myPetEnjoy()方法定义如下：

　　public void myPetEnjoy(){

　　　　pet.enjoy();

　　｝

　　然后在myPetEnjoy()方法体里面又使用pet引用对象去调用父类对象里面的enjoy方法。

　　方法是放在代码区(code seg)里面的，里面的方法就是一句句代码。因此当使用pet引用去访问父类对象的方法时，首先是找到这个父类对象，然后看看它里面的方法到底在哪里存着，找到那个方法再去执行。这里头就比较有意思了，code seg里面有很多个enjoy方法，有父类的enjoy()方法，也有子类重写了从父类继续下来的enjoy()方法，那么调用的时候到底调用的是哪一个呢？是根据谁来确定呢？注意：这是根据你实际当中的对象来确定的，你实际当中new出来的是谁，就调用谁的enjoy方法，当你找这个方法的时候，通过pet引用能找得到这个方法，但调用代码区里面的哪一个enjoy方法不是通过引用类型来确定的，如果是通过引用类型pet来确定，那么调用的肯定是Animal的enjoy()方法，可是现在是根据实际的类型来确定，我们的程序运行以后才在堆内存里面创建出一只Cat，然后根据你实际当中new出来的类型来判断我到底应该调用哪一个enjoy()方法。如果是根据实际类型，那么调用的就应该是Cat的enjoy()方法。如果是根据引用类型，那么调用的就应该是Animal的enjoy()方法。现在动态绑定这种机制指的是实际当中new的是什么类型，就调用谁的enjoy方法。所以说虽然你是根据我父类里面的enjoy方法来调用，可是实际当中却是你new的是谁调用的就是谁的enjoy()方法。即实际当中调用的却是子类里面重写后的那个enjoy方法。当然，讲一点更深的机制，你实际当中找这个enjoy方法的时候，在父类对象的内部有一个enjoy方法的指针，指针指向代码区里面父类的Animal的enjoy方法，只不过当你new这个对象的时候，这个指针随之改变，你new的是什么对象，这个指针就指向这个对象重写后的那个enjoy方法，所以这就叫做动态绑定。只有在动起来的时候，也就是在程序运行期间，new出了这个对象了以后你才能确定到底要调用哪一个方法。我实际当中的地址才会绑定到相应的方法的地址上面，所以叫动态绑定。调这个方法的时候，只要你这个方法重写了，实际当中调哪一个，要看你实际当中new的是哪个对象，这就叫多态，也叫动态绑定。动态绑定带来莫大的好处是使程序的可扩展性达到了最好，我们原来做这个可扩展性的时候，首先都是要在方法里面判断一下这只动物是哪一类里面的动物，通过if (object instanceof class)这样的条件来判断这个new出来的对象到底是属于哪一个类里面的，如果是一只猫，就调用猫的enjoy方法，如果是一条狗，就调用狗的enjoy方法。如果我现在增加了一个Bird类，那么扩展的时候，你又得在方法里面写判断这只鸟属于哪一个类然后才能调用这只鸟的enjoy方法。每增加一个对象，你都要在方法里面增加一段判断这个对象到底属于哪个类里面的代码然后才能执行这个对象相应的方法。即每增加一个新的对象，都要改变方法里面的处理代码，而现在，你不需要再改变方法里面的处理代码了，因为有了动态绑定。你要增加哪一个对象，你实际当中把这个对象new出来就完了，不再用去修改对象的处理方法里面的代码了。也就是当你实际当中要增加别的东西的时候，很简单，你直接加上去就成了，不用去改原来的结构，你要在你们家大楼的旁边盖一个厨房，很简单，直接在旁边一盖就行了，大楼的主要支柱什么的你都不用动，这就可以让可扩展性达到了极致，这就为将来的可扩展打下了基础，也只有动态绑定（多态）这种机制能帮助我们做到这一点——让程序的可扩展性达到极致。因此动态绑定是面向对象的核心，如果没有动态绑定，那么面向对象绝对不可能发展得像现在这么流行，所以动态绑定是面向对象核心中的核心。

　　总结动态绑定（多态）：动态绑定是指在“执行期间”（而非编译期间）判断所引用的实际对象类型，根据其实际的类型调用其相应的方法。所以实际当中找要调用的方法时是动态的去找的，new的是谁就找谁的方法，这就叫动态绑定。动态绑定帮助我们的程序的可扩展性达到了极致。

多态的存在有三个必要的条件：

1. 要有继承（两个类之间存在继承关系，子类继承父类）
2. 要有重写（在子类里面重写从父类继承下来的方法）
3. 父类引用指向子类对象

　　这三个条件一旦满足，当你调用父类里面被重写的方法的时候，实际当中new的是哪个子类对象，就调用子类对象的方法（这个方法是从父类继承下来后重写后的方法）。

　　面向对象比较强调类和类之间，对象和对象之间的一种组织关系，如果能把这种组织关系组织得比较好的话，你的程序想扩展性比较好，比较健壮，维护性比较好这些都可以达到，关键看你的设计到底好还是不好。