（三）黑马程序员——面向对象2

------- <a href="http://www.itheima.com" target="blank">android培训</a>、

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

面向对象(继承的好处和弊端)

* A:继承的好处

* a:提高了代码的复用性（如果再有个猪的类，只需要直接继承Animal就可以用了）

* b:提高了代码的维护性   如果要给动物加一个属性name，只需要在Aniaml中添加name就行

* c:让类与类之间产生了关系，是多态的前提

* B:继承的弊端

* 类的耦合性增强了。类与类之间的关系太紧密，一边添加属性，另一边就多了一个，有的时候是期望的，但是有的时候是不期望的。

* 开发的原则：高内聚，低耦合。内聚：是指自己完成事情的能力，自己能完成就不要麻烦别人

* 耦合：类与类的关系

* 内聚：就是自己完成某件事情的能力

面向对象(Java中类的继承特点)

* A:Java中类的继承特点

* a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹，多继承是有安全隐患的)

* 有些语言是支持多继承，格式：extends 类1,类2,...

* b:Java支持多层继承(继承体系)

* B:案例演示

* Java中类的继承特点

* 如果想用这个体系的所有功能用最底层的类创建对象

* 如果想看这个体系的共性功能,看最顶层的类 

案例：

class Demo2_Extends {
	public static void main(String[] args) {
		DemoC d = new DemoC();
		d.show();
	}
}
class DemoA {
	public void show() {
		System.out.println("DemoA");
	}
}
class DemoB extends DemoA {
	public void method() {
		System.out.println("DemoB");
	}
}
class DemoC extends DemoB {
	public void print() {
		System.out.println("DemoC");
	}
}

面向对象(继承的注意事项和什么时候使用继承)

* A:继承的注意事项

* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)

* b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。

* c:不要为了部分功能而去继承

* 项目经理 姓名 工号 工资 奖金

* 程序员 姓名 工号 工资

* B:什么时候使用继承

* 继承其实体现的是一种关系："is a"。

Person

Student

Teacher

水果

苹果

香蕉

橘子

采用假设法。

如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

案例：

class Demo3_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}
class Father {
	private String name;
	private void show() {
		System.out.println("Hello World!");
	}
}
class Son extends Father {
}

面向对象(继承中成员变量的关系)

* A:案例演示

* a:不同名的变量

* b:同名的变量

class Demo4_Extends {
	public static void main(String[] args) {
		Son s =  new Son();
		s.print();
	}
}
class Father {
	int num1 = 10;
	int num2 = 30;//先演示的时候,不加此处的num2
}
class Son extends Father {
	int num2 = 20;
	public void print(){
		System.out.println(num1);
		System.out.println(num2);
	}
}

面向对象(this和super的区别和应用)

* A:this和super都代表什么

* this:代表当前对象的引用,谁来调用我,我就代表谁

* super:代表当前对象父类的引用

* B:this和super的使用区别

* a:调用成员变量

* this.成员变量 调用本类的成员变量,也可以调用父类的成员变量

* super.成员变量 调用父类的成员变量

* b:调用构造方法

* this(...) 调用本类的构造方法

* super(...) 调用父类的构造方法

* c:调用成员方法

* this.成员方法 调用本类的成员方法,也可以调用父类的方法

* super.成员方法 调用父类的成员方法

案例：

class Demo4_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}
/*
* A:案例演示
	* a:不同名的变量
	* b:同名的变量
		子父类出现同名的变量只是在讲课中举例子有,在开发中是不会出现这种情况的
		子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
*/
class Father {
	int num1 = 10;
	int num2 = 30;
}
class Son extends Father {
	int num2 = 20;
	public void print() {
		System.out.println(this.num1);				//this既可以调用本类的,也可以调用父类的(本类没有的情况下)
		System.out.println(this.num2);				//就近原则,子类有就不用父类的了
		System.out.println(super.num2);
	}
}

面向对象(继承中构造方法的关系)

* A:案例演示

* 子类中所有的构造方法默认都会访问父类中空参数的构造方法

* B:为什么呢?

* 因为子类会继承父类中的数据，可能还会使用父类的数据。

* 所以，子类初始化之前，一定要先完成父类数据的初始化。

* 其实：

* 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

案例：

class Demo5_Extends {
	public static void main(String[] args) {
		Son s = new Son();
	}
}
class Father extends Object {
	public Father() {
		super();
		System.out.println("Father 的构造方法");
	}
}
class Son extends Father {
	public Son() {
		super();							//这是一条语句,如果不写,系统会默认加上,用来访问父类中的空参构造
		System.out.println("Son 的构造方法");
	}
}

面向对象(继承中构造方法的注意事项)

* A:案例演示

* 父类没有无参构造方法,子类怎么办?

* super解决:用super(....)显式调用父类的有参构造,如:super(name,age);->super("zs",30);

* this解决:通过this调用本类的有参构造,然后在本类的有参构造里,又调用了父类的有参构造,相当于间接调用父类的有参构造.

* B:注意事项

* super(…)或者this(….)必须出现在构造方法的第一条语句上,只能出现其一

案例：

class Demo6_Extends {
	public static void main(String[] args) {
		Son s1 = new Son();
		System.out.println(s1.getName() + "..." + s1.getAge());
		System.out.println("--------------------");
		Son s2 = new Son("张三",23);
		System.out.println(s2.getName() + "..." + s2.getAge());
	}
}
class Father {
	private String name;			//姓名
	private int age;				//年龄
	public Father() {				//空参构造
		System.out.println("Father 空参构造");
	}
	public Father(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
		System.out.println("Father 有参构造");
	}
	public void setName(String name) {	//设置姓名
		this.name = name;
	}
	public String getName() {			//获取姓名
		return name;
	}
	public void setAge(int age) {		//设置年龄
		this.age = age;
	}
	public int getAge() {				//获取年龄
		return age;
	}
}
class Son extends Father {
	public Son() {						//空参构造
		this("王五",25);				//本类中的构造方法
		//super("李四",24);				//调用父类中的构造方法
		
		System.out.println("Son 空参构造");
	}
	public Son(String name,int age) {	//有参构造
		super(name,age);
		System.out.println("Son 有参构造");
	}
}

面向对象(方法重写概述及其应用)

* A:什么是方法重写

* 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲) 

* B:方法重写的应用：

* 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

* C:案例演示

* a:定义一个手机类。

案例：

class Demo7_Phone {
	public static void main(String[] args) {
		Ios8 i = new Ios8();
		i.siri();
		i.call();
	}
}
class Ios7 {
	public void call() {
		System.out.println("打电话");
	}
	public void siri() {
		System.out.println("speak English");
	}
}
class Ios8 extends Ios7 {
	public void siri() {		
		System.out.println("说中文");
		super.siri();
	}
}

面向对象(方法重写的注意事项)

* A:方法重写注意事项

* a:父类中私有方法不能被重写

* 因为父类私有方法子类根本就无法继承,既然子类无法继承,就谈不上重写了

* b:子类重写父类方法时，访问权限不能更低

* 最好就一致

* c:父类静态方法，子类也必须通过静态方法进行重写

* 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)

* 子类重写父类方法的时候，最好声明一模一样。

* B:案例演示

* 方法重写注意事项

案例：

class Demo8_双桨 {
	public static void main(String[] args) {
		DayOne d = new DayOne();
		d.泡妞();
		d.print();
	}
}
class 双桨 {
	public void sing() {
		System.out.println("唱红歌");
	}
	public void 泡妞() {
		System.out.println("唱红歌搞定林夕合鸟女士");
	}
	public static void print() {
		System.out.println("Fu print");
	}
}
class DayOne extends 双桨 {
	public void 泡妞() {
		System.out.println("霸王硬上弓");
	}
	public static void print() {				//静态只能覆盖静态,其实不算重写,多态时候详细讲解
		System.out.println("Zi print");
	}
}

面向对象(final关键字修饰局部变量)

* 基本类型，是值不能被改变

* 引用类型，是地址值不能被改变,对象中的属性可以改变

面向对象(多态的概述及其代码体现)

* A:多态(polymorphic [,pɒlɪ'mɔːfɪk])概述

* 事物存在的多种形态 

* B:多态前提

* a:要有继承关系。

* b:要有方法重写。

* c:要有父类引用指向子类对象。

案例：

class Demo1_Polymorphic {
	public static void main(String[] args) {
		Cat c = new Cat();//猫是一只猫
		c.eat();
 
		Animal a = new Cat();				//父类引用指向子类对象，猫是一只动物
		a.eat();
	}
}
class Animal {
	public void eat() {
		System.out.println("动物吃饭");
	}
}
 
class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
		

面向对象(多态中的成员访问特点之成员变量)

* 成员变量

* 编译看左边(父类)，运行看左边(父类)。

/*

成员变量

编译看左边(父类),运行看左边(父类)

成员方法

编译看左边(父类)，运行看右边(子类)。动态绑定

静态方法

编译看左边(父类)，运行看左边(父类)。

(静态和类相关，算不上重写，所以，访问还是左边的)

只有非静态的成员方法,编译看左边,运行看右边 

*/

案例：

class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();					//父类引用指向子类对象
		System.out.println(f.num);			//相当于是Father.method()
      Son s = new Son();
      System.out.println(s.num);
	}
}
class Father {
	int num = 10;	
}
 
class Son extends Father {
	int num = 20;
}

面向对象(多态中的成员访问特点之成员方法)

* 成员方法

* 编译看左边(父类)，运行看右边(子类)。

案例：

class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();
		f.print();							//相当于是Father.method()
	}
}
class Father {
	int num = 10;
	public void print() {
		System.out.println("father");
	}
}
 
class Son extends Father {
	int num = 20;
	public void print() {
		System.out.println("son");
	}
}

面向对象(多态中的成员访问特点之静态成员方法)

* 静态方法

* 编译看左边(父类)，运行看左边(父类)。

* (静态和类相关，算不上重写，所以，访问还是左边的)

* 只有非静态的成员方法,编译看左边,运行看右边 

案例：

class Demo2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son();		
		f.method();							//相当于是Father.method()
	}
}
class Father {
	int num = 10;
	public static void method() {
		System.out.println("father static method");
	}
}
 
class Son extends Father {
	int num = 20;
	public static void method() {
		System.out.println("son static method");
	}
}

多态的好处和弊端：

* A:多态的好处

* a:提高了代码的维护性(继承保证)

* b:提高了代码的扩展性(由多态保证)

* B:案例演示

* 多态的好处

* 可以当作形式参数,可以接收任意子类对象

* C:多态的弊端

* 不能使用子类的特有属性和行为。