Java基础第九天

继承概述

引入

首先我来写两个代码：

//定义学生类
class Student
{
    public void study(){
		System.out.println("在教室学习");
	}
}
//定义老师类

class Teacher
{
	public void teach(){
		System.out.println("在教室教书");
	}
}

我们观察上面两个代码：

发现name，age成员变量，以及getXxx()/setXxx(),还有eat()等都是相同的。

如果我们后来继续定义类，举例：工人类，军人类。他们是不是也具备这些内容。

那么，我们每一次定义这样的类的时候，都要把这些重复的内容都重新定义一遍。

麻烦不?麻烦。所以，我们要考虑改进?

如何改进呢?

我这样想的：我能不能把这些相同的内容给定义到一个独立的类中。

然后，让这多个类和这个独立的类产生一个关系，有了这个关系后，

这多个类就可以具备这个独立的类的功能。

为了实现这个效果，java就提供了一个技术：继承。

父亲：

4个儿子

继承怎么表示呢?继承的格式是什么样子的呢?

class Fu {}

   class Zi extends Fu {

}

我们就回头修改我们的代码：

class Person
{
	String name;
	int age;

	public void eat(){
		System.out.println("吃饭");
	}
}

class Student extends Person
{
    public void study(){
		System.out.println("在教室学习");
	}
}

class Teacher extends Person
{
	public void teach(){
		System.out.println("在教室教书");
	}
}

class Worker extends Person
{
	public void work(){
	    System.out.println("在工作");
	}
}

继承概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

通过extends关键字可以实现类与类的继承

class 子类名 extends 父类名 {}  

单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。

继承的案例和继承的好处

通过一个具体案例来演示代码

案例1：学生类和老师。定义两个功能(吃饭，睡觉)

案例2：加入人类后改进。

/*

继承概述：

把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承呢?

Java提供了关键字：extends

格式：

class 子类名 extends 父类名 {}

好处：

A:提高了代码的复用性

B:提高了代码的维护性

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

*/

class Person
{
	String name;
	int age;

	public void eat(){
		System.out.println("吃饭");
	}
}

class Student extends Person
{
    public void study(){
		System.out.println("在教室学习");
	}
}

class Teacher extends Person
{
	public void teach(){
		System.out.println("在教室教书");
	}
}

class Worker extends Person
{
	public void work(){
	    System.out.println("在工作");
	}
}

class PersonTest
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.eat();
		s.study();
		Teacher t = new Teacher();
		t.eat();
		t.teach();
		Worker w = new Worker();
		w.eat();
		w.work();
		System.out.println("Hello World!");
	}
}

继承的好处

提高了代码的复用性

   多个类相同的成员可以放到同一个类中

提高了代码的维护性

   如果功能的代码需要修改，修改一处即可

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

Java中继承的特点

Java只支持单继承，不支持多继承。

一个类只能有一个父类，不可以有多个父类。

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2...//error

Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

/*

Java中继承的特点：

A:Java只支持单继承，不支持多继承。

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

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

*/

/*

class Father {}

class Mother {}

class Son exnteds Father {} //正确的

class Son extends Father,Mother {} // 错误的

*/

class GrandFather {
	public void show() {
		System.out.println("我是爷爷");
	}
}

class Father extends GrandFather {
	public void method(){
		System.out.println("我是老子");
	}
}

class Son extends Father {}

class ExtendsDemo2 {
	public static void main(String[] args) {
		Son s = new Son();
		s.method(); //使用父亲的
		s.show(); //使用爷爷的
	}
}

Java中继承的注意事项

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

  其实这也体现了继承的另一个弊端：打破了封装性

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

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

我们到底在什么时候使用继承呢?

继承中类之间体现的是：”is a”的关系。

/*

继承的注意事项：

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

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

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

class A {

public void show1(){}

public void show2(){}

}

class B {

public void show2(){}

public void show3(){}

}

//我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现

class B extends A {

public void show3(){}

}

这样其实不好，因为这样你不但有了show2(),还多了show1()。

有可能show1()不是你想要的。

那么，我们什么时候考虑使用继承呢?

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

Person

Student

Teacher

水果

苹果

香蕉

橘子

采用假设法。

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

*/

class GrandFather
{
	public int num1 = 10;
	public void show(){
		System.out.println("我是爷爷");
	}
}

class Father extends GrandFather
{
	public int num2 = 100;
	public int num1 =100000;
	public void method(){
		int num3 = 1000;
		int num1 = 20;
		System.out.println("我是老子");
		System.out.println(super.num1);
		System.out.println(num3);
		System.out.println(num1);
		System.out.println(this.num1);
	}
}
class Son extends Father
{
	public void fuction(){
		System.out.println(super.num1);
		System.out.println(num2);
	}
}


class ExtendsDemo2  
{
	public static void main(String[] args) 
	{
		Son son = new Son();
		son.show();
		son.method();
		son.fuction();
		System.out.println("Hello World!");
	}
}

继承中成员变量的关系

案例演示

子父类中同名和不同名的成员变量

/*

类的组成：

成员变量：

构造方法：

成员方法：

而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的组成部分的各自关系。

继承中成员变量的关系:

A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。

B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?

在子类方法中访问一个变量的查找顺序：

a:在子类方法的局部范围找，有就使用

b:在子类的成员范围找，有就使用

c:在父类的成员范围找，有就使用

d:如果还找不到，就报错。

*/

class Father {
	public int num = 10;
}

class Son extends Father {
	public int num = 20;
	
	public void show() {
		int num = 30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}

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

继承中构造方法的关系

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

为什么呢?

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

每一个构造方法的第一条语句默认都是：super()

/*

继承中构造方法的关系

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

B:为什么呢?

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

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

注意：子类每一个构造方法的第一条语句默认都是：super();

*/

class Father {
	int age;

	public Father() {
		System.out.println("Father的无参构造方法");
	}
	
	public Father(String name) {
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father {
	public Son() {
		//super();
		System.out.println("Son的无参构造方法");
	}
	
	public Son(String name) {
		//super();
		System.out.println("Son的带参构造方法");
	}
}	

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

如何父类中没有构造方法，该怎么办呢?

子类通过super去显示调用父类其他的带参的构造方法

子类通过this去调用本类的其他构造方法

    本类其他构造也必须首先访问了父类构造

一定要注意：

super(…)或者this(….)必须出现在第一条语句上

否则，就会有父类数据的多次初始化

/*

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?

报错。

如何解决呢?

A:在父类中加一个无参构造方法

B:通过使用super关键字去显示的调用父类的带参构造方法

C:子类通过this去调用本类的其他构造方法

子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：

this(...)或者super(...)必须出现在第一条语句上。

如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

*/

class Father {
	/*
	public Father() {
		System.out.println("Father的无参构造方法");
	}
	*/
	public Father(String name) {
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father {
	public Son() {
		super("随便给");
		System.out.println("Son的无参构造方法");
		//super("随便给");
	}
	
	public Son(String name) {
		//super("随便给");
		this();
		System.out.println("Son的带参构造方法");
	}
}

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

面试题一

/*

看程序写结果：

A:成员变量就近原则

B:this和super的问题

this访问本类的成员

super访问父类的成员

C:子类构造方法执行前默认先执行父类的无参构造方法

D:一个类的初始化过程

成员变量进行初始化

默认初始化

显示初始化

构造方法初始化

结果：

fu

zi

30

20

10

*/

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);//30
		System.out.println(this.num);//20
		System.out.println(super.num);//10
	}
}

class ExtendsTest 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
		System.out.println("Hello World!");
	}
}

面试题二

/*

看程序写结果：

A:一个类的静态代码块,构造代码块,构造方法的执行流程

静态代码块 > 构造代码块 > 构造方法

B:静态的内容是随着类的加载而加载

静态代码块的内容会优先执行

C:子类初始化之前先会进行父类的初始化

结果是：

静态代码块Fu

静态代码块Zi

构造代码块Fu

构造方法Fu

构造代码块Zi

构造方法Zi

*/

class Fu
{
	static{
		System.out.println("静态代码块Fu");
	}

	{
		System.out.println("构造代码块Fu");
	}

	public Fu(){
		System.out.println("构造方法Fu");
	}
}

class Zi extends Fu
{
	static{
		System.out.println("静态代码块Zi");
	}

	{
		System.out.println("构造代码块Zi");
	}

	public Zi(){
		//super();
		System.out.println("构造方法Zi");
	}
}

class ExtendsTest2 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		System.out.println("Hello World!");
	}
}

继承中成员方法的关系

案例演示

     子父类中同名和不同名的成员方法

结论：

  通过子类对象去访问一个方法

  首先在子类中找

  然后在父类中找

  如果还是没有就报错。(不考虑父亲的父亲…)

/*

继承中成员方法的关系:

A:子类中的方法和父类中的方法声明不一样，这个太简单。

B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?

通过子类对象调用方法：

a:先找子类中，看有没有这个方法，有就使用

b:再看父类中，有没有这个方法，有就使用

c:如果没有就报错。

*/

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

class Son extends Father {
	public void method() {
		System.out.println("method Son");
	}
	
	public void show() {
		System.out.println("show Son");
	}
}

class ExtendsDemo8 {
	public static void main(String[] args) {
		//创建对象
		Son s = new Son();
		s.show();
		s.method();
		//s.fucntion(); //找不到符号
	}
}

方法重写概述

方法重写概述

    子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。

使用特点：

   如果方法名不同，就调用对应的方法

   如果方法名相同，最终使用的是子类自己的

方法重写的应用：

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

/*

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：

本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：

先找子类本身，再找父类。

方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。

这样，即沿袭了父类的功能，又定义了子类特有的内容。

案例：

A:定义一个手机类。

B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。

按照我们基本的设计，我们把代码给写出来了。

但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。

其实这个时候的设计，并不是最好的。

因为手机打电话功能，是手机本身就具备的最基本的功能。

所以，我的新手机是不用在提供这个功能的。

但是，这个时候，打电话功能就没有了。这个不好。

最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。

那么，如何使用父类的功能呢?通过super关键字调用

*/

class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

class NewPhone extends Phone {
	public void call(String name) {
		//System.out.println("给"+name+"打电话");
		super.call(name);
		System.out.println("可以听天气预报了");
	}
}

class ExtendsDemo9 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}

方法重写的注意事项

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

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

父类静态方法，子类也必须通过静态方法进行重写。(其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解)

/*

方法重写的注意事项

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

因为父类私有方法子类根本就无法继承

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

最好就一致

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

其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

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

*/

class Father {
	//private void show() {}
	
	/*
	public void show() {
		System.out.println("show Father");
	}
	*/
	
	void show() {
		System.out.println("show Father");
	}
	/*
	public static void method() {
		
	}
	*/
	
	public void method() {
		
	}
}

class Son extends Father {
	//private void show() {}

	/*
	public void show() {
		System.out.println("show Son");
	}
	*/
	
	public void show() {
		System.out.println("show Son");
	}
	
	
	public static void method() {
	
	}
	
	/*
	public void method() {
	
	}
	*/
}

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

面试题

1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：

在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：

同一个类中，出现的方法名相同，参数列表不同的现象。

方法重载能改变返回值类型，因为它和返回值类型无关。

Override：方法重写

Overload：方法重载

2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用

super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：

成员变量：

this.成员变量

super.成员变量

构造方法：

this(...)

super(...)

成员方法：

this.成员方法

super.成员方法

继承练习

学生案例和老师案例讲解

 使用继承前

 使用继承后

父类中成员private修饰，子类如何访问呢?

/*

学生案例和老师案例讲解

学生：

成员变量；姓名，年龄

构造方法：无参，带参

成员方法：getXxx()/setXxx()

老师：

成员变量；姓名，年龄

构造方法：无参，带参

成员方法：getXxx()/setXxx()

看上面两个类的成员，发现了很多相同的东西，所以我们就考虑抽取一个共性的类：

人：

成员变量；姓名，年龄

构造方法：无参，带参

成员方法：getXxx()/setXxx()

学生 继承 人

老师 继承 人

*/

class Person
{
	//姓名
	private String name;

    private int age;
	public Person(){
	
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}

	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 Student extends Person
{
	public Student(){

	}
	public Student(String name,int age){
		super(name,age);
	}
}

class Teacher extends Person
{
	public Teacher(){

	}
	public Teacher(String name,int age){
		super(name,age);
	}
}

class Worker extends Person
{
	public Worker(){
	
	}
	public Worker(String name,int age){
		super(name,age);
	}
}



class ExtendsTest4  
{
	public static void main(String[] args) 
	{
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		System.out.println(s1.getName()+" \t"+s1.getAge());

		Student s2 = new Student("杨幂",23);
		System.out.println(s2.getName()+" \t"+s2.getAge());

		Teacher t1 = new Teacher();
		t1.setName("邓丽君");
		t1.setAge(38);
		System.out.println(t1.getName()+" \t"+t1.getAge());

		Teacher t2 = new Teacher("张三丰",54);
		System.out.println(t2.getName()+" \t"+t2.getAge());

		Worker w1 = new Worker();
		w1.setName("杨过");
		w1.setAge(25);
		System.out.println(w1.getName()+" \t"+w1.getAge());

		Worker w2 = new Worker("李思思",36);
		System.out.println(w2.getName()+" \t"+w2.getAge());
	}
}

猫狗案例讲解

分析和实现

/*

猫狗案例讲解

先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。

猫：

成员变量：姓名，年龄，颜色

构造方法：无参，带参

成员方法：

getXxx()/setXxx()

eat()

palyGame()

狗：

成员变量：姓名，年龄，颜色

构造方法：无参，带参

成员方法：

getXxx()/setXxx()

eat()

lookDoor()

共性：

成员变量：姓名，年龄，颜色

构造方法：无参，带参

成员方法：

getXxx()/setXxx()

eat()

把共性定义到一个类中，这个类的名字叫：动物。

动物类：

成员变量：姓名，年龄，颜色

构造方法：无参，带参

成员方法：

getXxx()/setXxx()

eat()

猫：

构造方法：无参，带参

成员方法：palyGame()

狗：

构造方法：无参，带参

成员方法：lookDoor()

*/

class Animal
{
	private String name;
	private int age;
	private String color;
	public Animal(){}
	public Animal(String name,int age,String color){
		this.name = name;
	}
	public void setName(String name){
		this.name = name;
		this.age = age;
		this.color = color;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	public void setColor(String color){
		this.color = color;
	}
	public String getColor(){
		return color;
	}
	public void eat(){
		System.out.println("别睡了，起来吃饭吧");
	}
}

class Cat extends Animal
{
	public Cat(){}

	public Cat(String name,int age,String color){
		super(name,age,color);
	}
	public void playGame(){
		System.out.println("猫玩英雄联盟");
	}
}

class Dog extends Animal
{
	public Dog(){}

	public Dog(String name,int age,String color){
        super(name,age,color);
	}
	public void lookDoor(){
		System.out.println("狗看家");
	}
}


class ExtendsTest5  
{
	public static void main(String[] args) 
	{
		Cat c1 = new Cat();
		c1.setName("Tom");
		c1.setAge(3);
		c1.setColor("白色");
		System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
		c1.eat();
		c1.playGame();
		System.out.println("---------------");

		Cat c2 = new Cat("杰瑞",5,"土豪金");
		System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
		c2.eat();
		c2.playGame();
		System.out.println("---------------");

		Dog d1 = new Dog();
		d1.setName("Tom");
		d1.setAge(3);
		d1.setColor("白色");
		System.out.println("狗的名字是："+d1.getName()+";年龄是："+d1.getAge()+";颜色是："+d1.getColor());
		d1.eat();
		d1.lookDoor();
		System.out.println("---------------");

		Dog d2 = new Dog("杰瑞",5,"土豪金");
		System.out.println("狗的名字是："+d2.getName()+";年龄是："+d2.getAge()+";颜色是："+d2.getColor());
		d2.eat();
		d2.lookDoor();

		
	}
}

final关键字

final关键字是最终的意思，可以修饰类，成员变量，成员方法。

  修饰类，类不能被继承

  修饰变量，变量就变成了常量，只能被赋值一次

  修饰方法，方法不能被重写

/*

继承的代码体现

由于继承中方法有一个现象：方法重写。

所以，父类的功能，就会被子类给覆盖调。

有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。

这个时候，针对这种情况，Java就提供了一个关键字：final

final:最终的意思。常见的是它可以修饰类，方法，变量。

*/

class Fu {
	public final void show() {
		System.out.println("这里是绝密资源,任何人都不能修改");
	}
}

class Zi extends Fu {
	// Zi中的show()无法覆盖Fu中的show()
	public void show() {
		System.out.println("这是一堆垃圾");
	}
}

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

 Final特性

/*

final可以修饰类，方法，变量

特点：

final可以修饰类，该类不能被继承。

final可以修饰方法，该方法不能被重写。(覆盖，复写)

final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。

常量：

A:字面值常量

"hello",10,true

B:自定义常量

final int x = 10;

*/

//final class Fu //无法从最终Fu进行继承

class Fu {
public int num = 10;
public final int num2 = 20;
 
/*
public final void show() {

}
*/
}
 
class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
num = 100;
System.out.println(num);

//无法为最终变量num2分配值
//num2 = 200;
System.out.println(num2);
}
}
 
class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

final关键字面试题

final修饰局部变量

   在方法内部，该变量不可以被改变

   在方法声明上，分别演示基本类型和引用类型作为参数的情况

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

          引用类型，是地址值不能被改变

/*

面试题：final修饰局部变量的问题

基本类型：基本类型的值不能发生改变。

引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。

*/

class Student {
	int age = 10;
}

class FinalTest {
	public static void main(String[] args) {
		//局部变量是基本数据类型
		int x = 10;
		x = 100;
		System.out.println(x);
		final int y = 10;
		//无法为最终变量y分配值
		//y = 100;
		System.out.println(y);
		System.out.println("--------------");
		
		//局部变量是引用数据类型
		Student s = new Student();
		System.out.println(s.age);
		s.age = 100;
		System.out.println(s.age);
		System.out.println("--------------");
		
		final Student ss = new Student();
		System.out.println(ss.age);
		ss.age = 100;
		System.out.println(ss.age);
		
		//重新分配内存空间
		//无法为最终变量ss分配值
		ss = new Student();
	}
}

final修饰变量的初始化时机

在对象构造完毕前即可

/*

final修饰变量的初始化时机

A:被final修饰的变量只能赋值一次。

B:在构造方法完毕前。(非静态的常量)

*/

class Demo {
	//int num = 10;
	//final int num2 = 20;
	
	int num;
	final int num2;
	
	{
		//num2 = 10;
	}
	
	public Demo() {
		num = 100;
		//无法为最终变量num2分配值
		num2 = 200;
	}
}

class FinalTest2 {
	public static void main(String[] args) {
		Demo d = new Demo();
		System.out.println(d.num);
		System.out.println(d.num2);
	}
}

多态

多态概述

某一个事物，在不同时刻表现出来的不同状态。

举例：

  猫可以是猫的类型。猫 m = new 猫();

  同时猫也是动物的一种，也可以把猫称为动物。

动物 d = new 猫();

 在举一个例子：水在不同时刻的状态

多态前提和体现

 有继承关系

 有方法重写

 有父类引用指向子类对象

多态案例及成员访问特点

/*

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。

举例：

猫是猫，猫是动物。

水(液体，固体，气态)。

多态的前提：

A:要有继承关系。

B:要有方法重写。

其实没有也是可以的，但是如果没有这个就没有意义。

动物 d = new 猫();

d.show();

动物 d = new 狗();

d.show();

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

父 f =  new 子();

用代码体现一下多态。

多态中的成员访问特点：

A:成员变量

编译看左边，运行看左边。

B:构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C:成员方法

编译看左边，运行看右边。

D:静态方法

编译看左边，运行看左边。

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

由于成员方法存在方法重写，所以它运行看右边。

*/

class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}
	
	public static void function() {
		System.out.println("function Fu");
	}
}

class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

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

class DuoTaiDemo {
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);
		//找不到符号
		//System.out.println(f.num2);
		
		f.show();
		//找不到符号
		//f.method();
		f.function();
	}
}

成员访问特点

成员变量

 编译看左边，运行看左边

成员方法

 编译看左边，运行看右边

静态方法

  编译看左边，运行看左边

 所以前面我说静态方法不能算方法的重写

多态的好处

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

/*

多态的好处：

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

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

猫狗案例代码

*/

class Animal
{
	public void eat(){
		System.out.println("eat");
	}
	public void sleep(){
		System.out.println("sleep");
	}
}

class Cat extends Animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void sleep(){
		System.out.println("猫趴着睡");
	}
}

class Dog extends Animal
{
	public void eat(){
		System.out.println("狗吃肉");
	}
	public void sleep(){
		System.out.println("狗站着睡");
	}
}

class Ultraman extends Animal
{
	public void eat(){
		System.out.println("奥特曼打小怪兽");
	}
	public void sleep(){
		System.out.println("奥特曼不用睡觉");
	}
}

class AnimalTools
{
	public static void animalTools(Animal a){
		a.eat();
		a.sleep();
	}
}

class DuoTai 
{
	public static void main(String[] args) 
	{
		Animal cat = new Cat();
		AnimalTools.animalTools(cat);
		Animal dog = new Dog();
		AnimalTools.animalTools(dog);
        Animal ultraman = new Ultraman();
        AnimalTools.animalTools(ultraman);
		//System.out.println("Hello World!");
	}
}

多态的弊端

不能访问子类特有功能

那么我们如何才能访问子类的特有功能呢?

多态中的转型

/*

多态的弊端：

不能使用子类的特有功能。

*/

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

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo3 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();
		f.method();
	}
}

多态中的转型问题

向上转型

  从子到父

  父类引用指向子类对象

向下转型

  从父到子

  父类引用转为子类对象

/*

多态的弊端：

不能使用子类的特有功能。

我就想使用子类的特有功能?行不行?

行。

怎么用呢?

A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)

B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：

向上转型：

Fu f = new Zi();

向下转型：

Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。

*/

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

class Zi extends Fu {
	public void show() {
		System.out.println("show zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}

}

class DuoTaiDemo4 {
	public static void main(String[] args) {
		//测试
		Fu f = new Zi();
		f.show();
		//f.method();
		
		//创建子类对象
		//Zi z = new Zi();
		//z.show();
		//z.method();
		
		//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
		//如果可以，但是如下
		Zi z = (Zi)f;
		z.show();
		z.method();
	}
}

多态成员访问及转型的理解

多态的问题理解：

class 孔子爹 {

public int age = 40;

public void teach() {

System.out.println("讲解JavaSE");

}

}

class 孔子 extends 孔子爹 {

public int age = 20;

public void teach() {

System.out.println("讲解论语");

}

public void playGame() {

System.out.println("英雄联盟");

}

}

//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了

//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?

//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹

//向上转型

孔子爹 k爹 = new 孔子();

//到人家那里去了

System.out.println(k爹.age); //40

k爹.teach(); //讲解论语

//k爹.playGame(); //这是儿子才能做的

//讲完了，下班回家了

//脱下爹的装备，换上自己的装备

//向下转型

孔子 k = (孔子) k爹;

System.out.println(k.age); //20

k.teach(); //讲解论语

k.playGame(); //英雄联盟

多态内存图

多态中对象变化的内存图解

/*

ClassCastException:类型转换异常

一般在多态的向下转型中容易出现

*/

class Animal {
	public void eat(){}
}

class Dog extends Animal {
	public void eat() {}
	
	public void lookDoor() {
	
	}
}

class Cat extends Animal {
	public void eat() {
	
	}
	
	public void playGame() {
		
	}
}

class DuoTaiDemo5 {
	public static void main(String[] args) {
		//内存中的是狗
		Animal a = new Dog();
		Dog d = (Dog)a;
		
		//内存中是猫
		a = new Cat();
		Cat c = (Cat)a;
		
		//内存中是猫
		Dog dd = (Dog)a; //ClassCastException
	}

案例练习

/*

多态练习：猫狗案例

*/

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

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor() {
		System.out.println("狗看门");
	}
}

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

class DuoTaiTest {
	public static void main(String[] args) {
		//定义为狗
		Animal a = new Dog();
		a.eat();
		System.out.println("--------------");
		//还原成狗
		Dog d = (Dog)a;
		d.eat();
		d.lookDoor();
		System.out.println("--------------");
		//变成猫
		a = new Cat();
		a.eat();
		System.out.println("--------------");
		//还原成猫
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
		System.out.println("--------------");
		
		//演示错误的内容
		//Dog dd = new Animal();
		//Dog ddd = new Cat();
		//ClassCastException
		//Dog dd = (Dog)a;
	}
}	

不同地方饮食文化不同的案例

Person

eat()

SouthPerson

eat()

NorthPerson

eat()

/*

不同地方饮食文化不同的案例

*/

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

class SouthPerson extends Person {
	public void eat() {
		System.out.println("炒菜,吃米饭");
	}
	
	public void jingShang() {
		System.out.println("经商");
	}
}

class NorthPerson extends Person {
	public void eat() {
		System.out.println("炖菜,吃馒头");
	}
	
	public void yanJiu() {
		System.out.println("研究");
	}
}

class DuoTaiTest2 {
	public static void main(String[] args) {
		//测试
		//南方人
		Person p = new SouthPerson();
		p.eat();
		System.out.println("-------------");
		SouthPerson sp = (SouthPerson)p;
		sp.eat();
		sp.jingShang();
		System.out.println("-------------");
		
		//北方人
		p = new NorthPerson();
		p.eat();
		System.out.println("-------------");
		NorthPerson np = (NorthPerson)p;
		np.eat();
		np.yanJiu();
	}
}

Java基础继承与多态