黑马程序员——JAVA之面向对象（二）

------- http://www.itheima.com" target="blank">android培训http://www.itheima.com"target="blank">java培训、期待与您交流！

 	
      一.、构造方法：
		1.当实例化一个类的对象时，JVM会自动调用本类的一个方法：构造方法；
		2.定义类时，可以不定义构造方法，编译器会自动添加一个无参的构造方法；
		3.如果类中定义了构造方法，编译器就不会添加任何构造方法了；
		4.构造方法的格式要求：
			1).构造方法名必须与类名一致；
			2).构造方法不能定义“返回值类型”，甚至是void；
			3).构造方法不能返回一个具体的值，但内部可以使用return;语句；
			注意：
			1).以下代码可以编译通过：
				class Student(){
					public void Student(){		//普通成员方法，不是构造方法；
					}
				}
			2).以下代码不能通过编译：
				class Student(){
					public student(){		//构造方法必须同类名一致，包括大小写；
					}
				}
		5.一个类中可以定义多个“构造方法”，但每个构造方法的形参列表不能完全相同，叫：构造方法的重载；
		6.在一个构造方法中可以调用另一个构造方法，使用this关键字；
		7.构造方法可以调用“成员方法”，但“成员方法”不能调用构造方法；
                  
	二、static关键字：
		1.static关键字：静态的，全局的。
		2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”，只有一份拷贝，被多个对象共享；
		3.特点：
		  	1).随着类的加载而加载
		  	2).优先于对象存在
		  	3).被类的所有对象共享
		  	4).可以通过类名调用，也可以通过对象名调用；
		4.static关键字注意事项：
			1).在静态方法中是没有this关键字的
			2).静态方法只能访问静态的成员变量和静态的成员方法
	三、静态变量和成员变量的区别：
		1.所属不同
			1).静态变量属于类，所以也称为为类变量
			2).成员变量属于对象，所以也称为实例变量(对象变量)
		2.内存中位置不同
			1).静态变量存储于方法区的静态区
			2).成员变量存储于堆内存
		3.内存出现时间不同
			1).静态变量随着类的加载而加载，随着类的消失而消失
			2).成员变量随着对象的创建而存在，随着对象的消失而消失
		4.调用不同
			1).静态变量可以通过类名调用，也可以通过对象调用
			2).成员变量只能通过对象名调用
	
        四、继承：
	      1.继承的关键字:extends
	      2.作用：提高了代码的复用性。为多态提供了前提；
	      3.this和super的区别：
		1).this:
			1).在任何类中使用；
			2).存储的是本类对象的引用；
			3).可以访问本对象的成员变量、成员方法、构造方法；
		2).super:
			1).在子类中使用；
			2).存储的是父类对象的引用；
			3).可以访问父类对象的成员变量、成员方法、构造方法；
	      4.类的初始化过程：
		加载class文件
		堆中开辟空间
		变量的默认初始化
		变量的显示初始化
		构造代码块初始化
	 	构造方法初始化
	        成员变量-->构造代码块-->构造方法
	      5.Java中继承的特点：
		1).Java中只能单继承；
		2).Java中可以多级继承；
	      6.继承的好处和弊端：
		好处：1).代码复用    2).为多态提供了前提；
		弊端：1).由于继承，子类对父类产生了依赖；
      五、方法重写:
	     1.在子类中，定义跟父类一模一样的方法，这叫：方法重写；
	     2.重写的规则：
		1).返回值类型、方法名、形参列表：要完全一致；
		2).子类的访问修饰符可以跟父类的相同，或更宽；
	     3.重写的意义：
		1).子类保留了父类的方法，具有了自己特有的行为；
	     4.重写和重载的区别：
		1).重写：在子类中定义跟父类一模一样的方法；
		2).重载：在一个类中，定义：方法名相同，参数列表不完全相同的方法，叫：重载。跟返回值类型无关；

	
      六、final关键字：
	     1.可以修饰：
		成员变量：表示其变量拥有最终的值，不能被更改，成为"常量"。修饰基本数据类型：表示其值不能被修改。修饰引用数据类型，表示地址不能被修改；
		成员方法：表示最终的方法。不能被重写；
		类：	  表示最终类。不能被继承；
		局部变量：表示其值不能改变；区分：基本类型和引用类型；
		方法形参：表示其值不能改变；区分：基本类型和引用类型；
      七、多态：
	    1.父类的引用指向子类的对象；
	    2.多态前提和体现
		1).有继承关系	
		2).有方法重写	
	 	3).有父类引用指向子类对象
	    3.多态的转型：
		1).自动转型：子类的引用转为父类的引用；Person p = new Student();
		2).强制转型：父类的引用转为它所指向的子类对象的引用；Student stu = (Student)p;
			3).在进行强制转型前，为保证安全，可以使用instanceof关键字进行判断：
				if(p instanceof Student){
					Student stu = (Student)p;
				}
	    4.多态的好处：
		1).提高了程序的维护性(由继承保证)
		2).提高了程序的扩展性(由多态保证)
	5.多态的弊端：
		1).不能访问子类特有功能(可以向下转型)
	6.多态时的访问规则：
		1).总体规则：访问的任何成员父类中必须要有，否则编译错误；
				例如：
					class A{
						int num = 10;
					}
					class B extends A{
						int n = 20;
					}
					main(){
						A a = new B();
						System.out.println(a.n);	//编译错误，父类中没有n
					}
		2).成员变量：如果子、父类中都有，访问的是“父类”的；
					class A{
						int num = 10;
					}
					class B extends A {
						int num = 20;
					}
					main(){
						A a = new B();	//多态
						System.out.println(a.num);	//打印10； 
					}
	     普通方法：如果子、父类中都有(重写)，访问的是“子类”的；
					class A{
						void show(){
							System.out.println("A-->show()");
						}
					}
					class B extends A{
						void show(){
							System.out.println("B-->show()");
						}
					}
					main(){
						A a = new B();
						a.show();	//打印：B-->show()(访问的是子类的show());
					}
	      静态方法：如果子、父类中都有(重写)，访问的是“父类”的；
			

	八、抽象类：
		1.使用abstract关键字修饰；可以修饰“类”，可以修饰“成员方法”；
			abstract class A{
				abstract void show();
			}
		2.“抽象类”的特点：
			1).不能被实例化，只能用于被继承；
			2).可以包含：成员变量、构造方法、成员方法、抽象方法；
			3).可以不包含抽象方法；
		3.“抽象方法”的特点：
			1).没有方法体；abstract void show();
			2).必须被子类重写。除非子类也是个抽象类；
		3.子类继承抽象类使用关键字：extends，仍然是单继承；
		4.一个子类继承 了一个抽象类，必须实现抽象类中所有的抽象方法；
		  否则子类也必须是抽象的。
			例如：
				abstract class A{
					abstract void show();
				}
				class B extends A{  }	//编译错误。类B不是抽象的，继承类抽象类必须重写抽象类中的所有抽象方法。
				abstract class B extends A{  }	//编译通过。类B没有重写父类中的抽象方法，但类B是抽象的。
		5.abstract关键字不能和哪些关键字共存：
			1).private:抽象方法就是用来被子类重写的，而私有方法不能被子类重写；
			2).final：抽象类和抽象方法就是用来被子类继承和重写的，而final类和final方法不能
                                 被继承和重写；
			3).static：static修饰的方法在没有任何对象的情况下就会被分配内存空间；而抽象方法
                                  没有方法体，无法分配空间；
	九、接口：
		1.使用interface关键字定义：只能修饰“类”：
			interface IA{
			}
		2.“接口”的特点：
			1).不能被实例化，没有构造方法，只能用于子类“实现”；
			2).可以包含：
				A.成员变量(常量)：隐式的定义为：public static final。
				            	  上述三个关键字中任何一个都可以不写，系统会自动添加；
						例如：
						interface IA{
							public int num1 = 10;		//OK
							static final int num2 = 20;	//OK
							final int num3 = 30;		//OK
							public final num4 = 40;		//OK
							int num5 = 50;			//OK
						}
				B.抽象方法：隐式的定义为：public abstract。可以省略，系统会自动添加
						例如：
						interface IA{
							void show1();		//OK
							public void show2();	//OK;
							abstract void show3();	//OK;
						}
			3).接口的功能是：扩展功能；
		3.子类实现接口使用关键字：implements
		4.一个子类可以同时实现多个接口；
			interface IA{}
			interface IB{}
			class C implements IA,IB{	//OK的。
			}
		5.子类实现接口时，必须重写接口中所有的抽象方法，而且必须是public的--因为接口中抽象方法的定义隐式的是public的。
				例如：
					interface IA{
						void show();
					}
					class B implements IA{
						void show(){  }       //编译错误。父接口的show()隐式的为public的，子类重写时必须是public的；
					}
				
		6.接口编译后一样会生成.class文件。
   
                  十、类与类，类与接口，接口与接口的关系：
		1.类与类：继承关系，关键字：extends ，只能单继承，但是可以多层继承
		2.类与接口：实现关系，关键字：implements ，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
		3.接口与接口：继承关系，关键字：extends，可以单继承，也可以多继承
			例如：
				interface IA{}
				interface IB{}
				interface IC extends IA,IB{}	//OK的
                 十一、抽象类和接口的区别：
		1.成员区别
			1).抽象类 变量,常量;有抽象方法;非抽象方法
			2).接口 常量;抽象方法
		2.关系区别
			1).类与类 继承，单继承
			2).类与接口 实现，单实现，多实现
			3).接口与接口 继承，单继承，多继承
		3.设计理念区别
			1).抽象类 被继承体现的是：”is a”的关系。共性功能
			2).接口 被实现体现的是：”like a”的关系。扩展功能
                 十二、包：
		1.定义包使用关键字：package；
			1).注意事项：
				A.package语句必须是程序的第一条可执行的代码
				B.package语句在一个java文件中只能有一个
				C.如果没有package，默认表示无包名

		2.导入包使用关键字：import；
			1).注意事项：
				A.导入到最终的类；
				B.可以使用通配符：*，只统配包下的类，不包括子包下的其它类；
				C.在一个类文件中，可以有多条import语句；
				D.import语句必须在package语句之后，在定义类之前；
		3.package,import,class有没有顺序关系？
			有：package-->import-->class
                十三、访问修饰符：
		1.用于限定“类”和“成员”被其它包下的其它类访问的；
		2.四种访问修饰符：
			1).public(公有)：可以修饰类、成员。可以被任何包下的其它类访问；
			2).protected(保护)：可以修饰成员。可以被同包下的其它类访问。如果在包外
                                            只能被子类访问；
			3).(默认)：可以修饰类、成员。只能被包内的其它类访问；
			4).private(私有)：可以修饰成员。只能被类中的其它方法访问；
		3.类及成员可用的修饰符：
			1).类：
				默认，public，final，abstract
				我们自己定义：public居多
			2).成员变量：
				四种权限修饰符均可,final,static
				我们自己定义：private居多
			3).构造方法：
				四种权限修饰符均可,其他不可
				我们自己定义：public 居多
			4).成员方法：
				四种权限修饰符均可，fianl,static,abstract
				我们自己定义：public居多
              十四、内部类：
		1.成员内部类：
			1).定义在类体中，作为类的成员；
			2).可以使用同类“成员方法”相同的修饰符；
		2.局部内部类：
			1).定义在某个方法或代码块内部；
			2).不能使用“访问修饰符”，不能使用static修饰符；可以使用final和abstract
			3).注意：局部内部类访问“局部变量”，要求局部变量必须是final的(常量)；
		3.匿名内部类：
			1).就是内部类的简化写法。
			2).前提：存在一个类或者接口
				 这里的类可以是具体类也可以是抽象类。
			3).格式：
				new 类名或者接口名() {重写方法;}
			4).本质：
				是一个继承了类或者实现了接口的子类匿名对象