黑马程序员_面向对象之继承

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流------

1  代码块:   在java语言中使用{}括起来的内容就是代码块
代码块的分类:
局部代码块  , 构造代码块 , 静态代码块 , 同步代码块(多线程在讲解)

局部代码块:
位置: 在局部位置(在方法定义中) , 限定变量生命周期，及早释放，提高内存利用率
构造代码块:
位置: 在成员位置(在类中方法外) , 特点: 每创建一次对象都要调用一次构造代码块.并且优先于构造方法执行
 多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块: 
在成员位置(在类中方法外), 需要在前面添加一个关键字: static
特点:随着类的加载而加载,只执行一次,并且优先于构造代码块以及构造方法
用于给类进行初始化，在加载的时候就执行，并且只执行一次。

静态代码块是随着类的加载而加载的,并且只加载一次,优先于构造代码块以及构造方法执行
构造代码块: 每创建一次对象都要执行一次,并且优先于构造方法执行
构造方法: 每创建一次对象都要执行一次

class Code {

	// 静态代码块
	static {
		System.out.println("静态代码块执行了....");
	}
	
	// 构造代码块
	{
		System.out.println("构造代码块被调用了");
	}

	public Code(){
		System.out.println("构造方法被调用了");
	}

	public Code(String name){
		System.out.println(name);
	}

}

// 测试类
class CodeTest {

	public static void main(String[] args){
		
		// 局部代码块
		{
			int x = 20 ;
			System.out.println(x);
		}


		// System.out.println(x);

		System.out.println("----------------------");

		// 创建Code对象
		Code c1 = new Code();

		System.out.println("----------------------");

		Code c2 = new Code();

		System.out.println("----------------------");

		Code c3 = new Code("小迪");
	
	}

}

继承的好处: extends
a: 提高了代码的复用性
b: 提高了代码的维护性
c: 让类与类产生了关系,是多态的前提
继承的弊端:
让类与类产生了关系, 提高了耦合性
开发原则: 高内聚 , 低耦合
内聚: 就是完成某一个功能的能力
耦合: 类与类的关系
  
  继承的特点:
a: 在java语言中,只支持单继承 ,不支持多继承
b: 在java语言中,支持多层继承

class GrandFather {

	public void show(){
		System.out.println("GrandFather ... show ....");
	}

}

class Father extends  GrandFather {

	public void method(){
		System.out.println("father .... method ....");
	}

}

// 错误的: 在java语言中,只支持单继承 ,不支持多继承
// class Son extends  Father , GrandFather {}

class Son extends Father {

}


// 测试类
class ExtendsTest {
	
	public static void main(String[] args){
	
		// 创建Son对象
		Son s = new Son();

		// 调用method方法
		s.method();

		// 调用show方法
		s.show();

	}

}

继承中成员变量的访问:
a: 子类中的成员变量和父类中的成员变量名称不一样
b: 子类中的成员变量和父类中的成员变量名称一样

变量的访问遵循一个原则: "就近原则"

a: 在子类中的局部位置查找
b: 在子类的成员位置查找
c: 在父类中的成员位置查找
d: 就报错了

this和super的区别:
this: 代表的是本类对象的一个引用,谁调用我方法中的this就代表谁
super: 代表的是父类存储空间的一个标识(理解: 父类对象的引用)
this和super访问成员的格式:
a: 访问成员变量的格式
this.变量名  本类对象的成员变量
super.变量名  父类对象的成员变量
b: 访问构造方法的格式:
this(...):  访问的是本类的构造方法
super(...):  访问父类的构造方法
c: 访问成员方法的格式:
this.方法名(...)  访问的是本类的成员方法
super.方法名(...)访问的是父类的成员方法

// 父类
class Father {
	
	int num = 30 ;

}

// 子类
class Son extends Father {
	
	int num = 60 ;

	public void show(){
		int num = 70 ;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}

}

// 测试类
class ExtendsTest {

	public static void main(String[] args){
	
		// 创建一个Son对象
		Son s = new Son();

		// 调用show方法
		s.show();
	}

}

子类中所有的构造方法默认都会访问父类中空参数的构造方法为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
每一个构造方法的第一条语句默认都是：super()
Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。
如果父类中没有无参的构造方法,子类如何创建对象?

解决方案:
a: 在父类中添加一个无参的构造方法
b: 使用super去显式的调用父类有参的构造方法
c: 在子类中去调用其他的构造方法,其他的构造方法要去显式的调用父类有参的构造方法
注意事项:
super(…)或者this(….)必须出现在第一条语句上
如果是不放在第一句上,就可以出现对父类的数据进行多次初始化,所以必须放在第一句
 继承中成员方法的访问:
a: 子类中的成员方法和父类中的成员方法的名称不一致的时候
b: 子类中的成员方法和父类中的成员方法的名称一致的时候
查找顺序:
(1): 在子类的成员位置
(2): 在父类的成员位置
(3): 报错

继承的注意事项:
a: 子类只能继承父类所有非私有的成员(成员方法和成员变量)
b: 子类不能继承父类的构造方法，但是可以通过super(待会儿讲)关键字去访问父类构造方法。
c: 不要为了部分功能而去继承

// 父类
class Fu{

	public int num = 10;

	public Fu(){
		System.out.println("fu");
	}
}

// 子类
class Zi extends Fu{

	public int num = 20;

	public Zi(){
		System.out.println("zi");
	}
	public void show(){

		int num = 30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}

// 测试类
class Test {

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

方法重写:子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
方法重写: 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
  方法重写的注意事项:
a: 父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
b: 子类重写父类方法时，访问权限不能更低
在重写父类的方法的时候,要求子类的方法访问权限要大于或者等于父类的方法访问权限
建议: 在重写的时候方法的访问权限一致
c: 父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
Override和Overload的区别?Overload能改变返回值类型吗?
Override: 方法重写
发生在子父类中, 子类出现了和父类一模一样的方法(方法名, 参数列表 , 返回值类型), 方法重写
Overload: 方法重载
方法重载: 在同一个类中,允许同时存出一个以上的同名方法,只要它们的参数列表不同,与返回值无关
Overload能改变返回值类型吗? 可以,因为和返回值类型无关
f inal关键字:
有时候我们不希望子类去复写父类的方法.
我们如果想让子类不能复写父类的方法,java就给我们提供了一个关键字: final
final: 最终的   

class Father {

	public final void show(){
		System.out.println("这是不能随便更改滴...");
	}

}

class Son extends Father {
	
	// 错误的: final
//	public void show(){
//		System.out.println("这是写不了的, 你骗我!!!");
//	}
 
}

// 测试类
class FinalTest {

	public static void main(String[] args){
		
		// 创建Son对象
		Son s = new Son();

		// 调用show方法
		s.show();
	
	}

}		 

final关键字的特点:
修饰类 被修饰的类不能被子类继承
成员方法 被修饰的成员方法不能被子类重写
变量 被final修饰的变量,本质上是一个常量,其值不能被改变
final修饰变量的初始化时机
a: 被final修饰的变量只能赋值一次
b:在构造方法完毕前即可(非静态的常量)