java基础知识七（面向对象二）

第1章 继承

1.1 继承的概述

1.1.1 继承概述

• 多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可
• 单独的这个类称为父类，基类或者叫超类，多个类可以称为子类或者派生类
• 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员
  1.1.2 实现继承的方式
  通过extends关键字可以实现类与类的继承
  格式：
  public class 子类名 extends 父类名{}

public class Person {
	private String name;
	private int age;
	
	public Person() {}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}


public class Student extends Person {
	public void study() {
		System.out.println("学生要好好学习");
	}
}



public class Teacher extends Person {
	public void teach() {
		System.out.println("老师要好好讲课");
	}
}

1.2 继承的好处和弊端

1.2.1 继承的好处
• 提高了代码的复用性
多个类相同的成员可以放到同一个类中
• 提高了代码的维护性
如果功能的代码需要修改，修改一处即可
• 让类与类之间产生了关系，是多态的前提
1.2.2 继承的弊端
• 好处的第三点同时也是继承的弊端
类与类之间产生了关系，让类的耦合性增强了
设计原则：高内聚低耦合

public class Person {
	private String name;
	private int age;
	
	public Person() {}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

1.3 Java 中继承的特点

1.3.1 Java中单继承以及多级继承
• Java中只支持单继承，不支持多继承
– 一个类只能有一个父类，不可以有多个父类
– public class Son extends Father{} // ok
– public class Son extends Father,GrandFather // Error

• Java中类支持多层继承(继承体系)
– Public class GrandFather{}
– Public class Father extends GrandFather{}
– Public class Son extends Father{}

public class Father extends GrandFather {
	public void fatherSay() {
		System.out.println("爸爸都是从儿子走过来的");
	}
}

package com.itheima_03;

public class GrandFather {
	public void grandFatherSay() {
		System.out.println("爷爷都是从孙子熬过来的");
	}
}



/*
public class Son extends GrandFather {
	public static void main(String[] args) {
		Son s = new Son();
		s.grandFatherSay();
	}
}
*/

/*
public class Son extends Father {
	public static void main(String[] args) {
		Son s = new Son();
		s.fatherSay();
	}
}
*/

//Java中类只支持单继承，不支持多继承
/*
public class Son extends Father,GrandFather {
	public static void main(String[] args) {
		Son s = new Son();
		s.fatherSay();
	}
}
*/

//Java中类支持多层继承
public class Son extends Father {
	public static void main(String[] args) {
		Son s = new Son();
		s.fatherSay();
		s.grandFatherSay();
	}
}

1.4 Java继承中成员变量的特点

1.4.1 Java继承中成员变量的特点
• 成员变量名称不一样，使用的时候非常简单
• 成员变量名称一样的情况：
– 在子类中访问变量：（就近原则）
• 在方法的局部范围找，如果有就使用
• 在子类的成员范围找，如果有就使用
• 在负累的成员范围找，如果有就使用
• 如果还找不到 就报错

第2章 super关键字以及继承中的方法重写

2.1 super关键字的概述和使用

2.1.1 super关键字的概述
• super的用法和this很像
this代表本类对象的引用
super代表父类存储空间的标识（可以理解为父类对象引用）
• 用法（this和super均可如下使用）
访问成员变量
• this.成员变量 super.成员变量
• 访问构造方法
• this(…) super(…)
• 访问成员方法
• this.成员方法() super.成员方法()

public class Son extends Father {
	public int age = 20;
	
	public void printAge() {
		int age = 10;
		System.out.println(age);
		//我要访问成员范围的age?
		System.out.println(this.age);
		//我要访问父类成员范围的age?
		System.out.println(super.age);
	}
}
package com.itheima_02;

public class ExtendsTest {
	public static void main(String[] args) {
		Son s = new Son();
		s.printAge();
	}
}

2.2 Java继承中构造方法的特点

• 子类中所有的构造方法默认都会访问父类中空参数的构造方法
• 为什么呢？
因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
每一个构造方法的第一条默认语句都是super
• 如果父类中没有构造方法，该怎么办呢？
在父类中加一个无参的构造方法
通过使用super关键字去显示的调用父类的带参构造方法
通过这里我们发现第一种解决方案最简单，所以，建议我们自定义类的时候永远自己给出无参构造方法

public class Son extends Father {
	public Son() {
		//super();
		super("林青霞");
		System.out.println("Son无参构造方法");
	}
	
	public Son(String name) {
		//super();
		super("林青霞");
		System.out.println("Son带参构造方法");
		System.out.println(name);
	}
}
package com.itheima_03;

public class ExtendsTest {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("---------");
		Son s2 = new Son("林青霞");
	}
}

2.3 Java继承中成员方法的特点

2.3.1 Java 继承中成员方法的特点
• 通过子类对象去访问一个方法
首先在子类中找
然后在父类中找
如果还是没有就会报错

2.4 方法重写的概述和使用

2.4.1 方法重写的概述
方法重写：子类中出现了和父类中一摸一样的方法声明

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

2.4.3 方法重写的注意事项

• 注解
  @Override
  表明该方法的重写父类的方法
• 方法重写的注意事项:
  父类中私有方法不能被重写
  子类重写父类方法时，访问权限不能更低
  子类重写父类方法时，建议访问权限一摸一样

第3章 多态

3.1 多态的概述和代码体现

• 多态概述
– 某一个事物，在不同时刻表现出来的不同状态。
• 举例
– 猫可以是猫的类型。猫 m = new 猫();
– 同时猫也是动物的一种，也可以把猫称为动物
• 动物 d = new 猫();
• 水在不同时刻的状态
• 多态的前提和体现
– 有继承关系
– 有方法重写
– 有父类引用指向子类对象

3.2 多态中成员的访问特点

3.2.1 多态中成员访问特点
·成员变量访问特点

• 编译看左边，运行看左边
  ·成员方法访问特点
• 编译看左边，运行在左

3.3 多态的好处和弊端

• 多态的好处
  提高了程序的扩展性
• 多态的弊端
  不能访问子类特有功能
  那么如何访问子类的特有功能呢？
  通过多态中的转型

3.4 多态中的转型问题

向上转型
从子到父
父类引用指向子类对象

• 向下转型
  从父到子
  父类引用转为子类对象

public class DuoTaiDemo {
	public static void main(String[] args) {
		//多态
		Animal a = new Cat(); //向上转型
		a.eat();
		
		//a.playGame();
		//多态的弊端：无法访问子类特有方法
		//现在我就想使用子类特有方法，怎么办呢?
		//创建子类对象就可以了
		/*
		Cat c = new Cat();
		c.eat();
		c.playGame();
		*/
		//现在的代码虽然可以访问子类的特有功能，但是不合理
		//因为我们发现内存中有两个猫类的对象
		//这个时候，我们得想办法把多态中的猫对象还原
		//这个时候，就要使用多态中的转型了
		//父类引用转为子类对象
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
	}
}
package com.itheima_04;

public class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}
package com.itheima_04;

public class Animal {
	public void eat() {
		System.out.println("吃东西");
	}
}

3.5 多态中的内存图