2021-04-01

Java学习

day10

前言
继承的三个特点:

目录

1. 多态
2. 抽象类

1、多态
1.1、多态的概述
什么是多态:
同一个对象，在不同时刻表现出来的不同形态。
多态的前提:
要有继承或实现关系要有方法的重写要有父类引用指向子类对象。
1.2、多态中的成员方法的特点
成员访问特点
成员变量
编译看父类，运行看父类
成员方法
编译看父类，运行看子类
1.3、多态的好处和弊端
好处: 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。
弊端: 不能使用子类的特有成员。
1.4、多态的转型
向上转型……父类引用指向子类对象就是向上转型
向下转型……格式：子类型对象名=(子类型)父类引用;
1.5、例一:
程序代码如下:
①
package com.hg.day10.demo01;

public class Fu {
int num = 10;

public Fu() {
	//TODO 自动生成的构造函数
}
public Fu(int num) {
	//TODO 自动生成的构造函数
}

}
②
package com.hg.day10.demo01;
/*

• this
  

• 1.访问本类的成员变量

• 2.在本类成员变量中，访问另一个成员方法

• 3.在构造函数中调用this方法

• */
  public class Zi extends Fu {
  int num = 20;

  public Zi() {
  //this(100); ！！ this和super只能调用一个 ！!

   super();
   System.out.println("我是子类的无参构造方法");
  

  }
  public Zi(int n) {
  this.num = n;
  System.out.println(“我是子类的有参构造方法”+n);
  }
  public Zi(int n,String name) {
  this(1000);
  //只初始化name相关工作
  System.out.println(“我是子类的有参构造方法”+n);
  }
  public void showNum() {
  int num = 30;
  System.out.println(num);
  System.out.println(this.num);
  System.out.println(super.num);
  }
  public void methodA() {
  System.out.println(“AAA”);
  }
  public void methodB() {
  this.methodA();
  System.out.println(“BBB”);
  }

}
③
package com.hg.day10.demo01;

public class demo01Extends {
public static void main (String[] agrs) {
Zi zi = new Zi();
}
}
运行结果:

2、抽象类
2.1、概述
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

2.2、抽象类的特点
①抽象类和抽象方法必须使用abstract关键字修饰
②抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
//抽象类的定义publicabstractclass类名{}
//抽象方法的定义publicabstractvoideat();
③抽象类不能实例化
抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态。
④抽象类的子类要么重写抽象类中的所有抽象方法要么是抽象类。
2.3、抽象类的成员特点
①成员的特点
成员变量 既可以是变量，也可以是常量
②构造方法
空参构造 有参构造
③成员方法
抽象方法 普通方法
2.4、例二
①
package com.hg.day10.demo02;
/*

• 抽象方法 + Abstract关键字，去掉大括号，直接分号结束。

• 1.抽象类不能直接使用，不能直接实例化

• 2.必须用一个子类来继承抽象的父类

• 3.子类必须 覆盖重写 抽象父类中的所有抽象方法
  */
  public abstract class Animal {
  public Animal() {
  System.out.println(“抽象父类中的构造方法”);
  }
  public abstract void eat();

  public abstract void foot();

  public void normalMethod() {

  }

}
②
package com.hg.day10.demo02;

public class Cat extends Animal {

public Cat () {
	System.out.println("子类中的构造方法");
}
@Override  // 重写
public void eat() {
	System.out.println("猫吃鱼");
}
public void foot() {
	
}

}
③
package com.hg.day10.demo02;
/*

•  一个抽象类 不一定含有 抽象方法
  

• 但是，一个有抽象方法的类一定含有抽象方法
  */
  public abstract class MyAbstract {
  public void sleep() {

  }

}
④调用
package com.hg.day10.demo02;

public class Demo02Main {
public static void main (String[] agrs) {

	Cat cat = new Cat();
	cat.eat();
}

}
运行结果:

例二:
①
package com.hg.day10.demo03;

/*

• 抽象方法 + Abstract关键字，去掉大括号，直接分号结束。

• 1.抽象类不能直接使用，不能直接实例化

• 2.必须用一个子类来继承抽象的父类

• 3.子类必须 覆盖重写 抽象父类中的所有抽象方法

• */
  public abstract class Animal {
  public Animal() {
  System.out.println(“抽象父类中的构造方法”);
  }
  public abstract void eat();

  public abstract void sleep();
  }
  ②
  package com.hg.day10.demo03;

public abstract class Dog extends Animal {

@Override  // 重写
public void eat() {
	System.out.println("狗吃骨头");
}

}
③
package com.hg.day10.demo03;

public class Dog2ha extends Dog {

@Override  // 重写
public void sleep() {
	System.out.println("二哈睡觉");
}

}
④
package com.hg.day10.demo03;

public class DogGolden extends Dog {

@Override  // 重写
public void sleep() {
	System.out.println("躺着沙发睡觉");
}

}
⑤
package com.hg.day10.demo03;

public class Demo03Main {
public static void main (String[] args) {
//不能实例化：
//Animal animal = new Animal();
//Dog dog = new Dog();
//可以实例化：
Dog2ha ha2 = new Dog2ha();
ha2.eat();
ha2.sleep();
System.out.println("==========");

DogGolden doggolden = new DogGolden();
doggolden.eat();
doggolden.sleep();
}

}
运行结果:

tip:2020080605006