多态的概述及其代码体现
- 多态(polymorphic)概述
- 事物存在的多种形态
- 多态前提
- 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("猫吃鱼");
}
}运行结果为猫吃鱼 猫吃鱼
多态中的成员访问特点之成员变量
- 成员变量
- 编译看左边(父类)，运行看左边(父类)。
- 编译看左边(父类)，运行看左边(父类)。
运行结果为 10 20
多态中的成员访问特点之成员方法
- 成员方法
- 编译看左边(父类)，运行看右边(子类)。
将Father.class 中的print方法注释掉就会报错:找不到符号 f.print();
运行结果为 son
多态中的成员访问特点之静态成员方法
- 静态方法
- 编译看左边(父类)，运行看左边(父类)。
- (静态和类相关，算不上重写，所以，访问还是左边的)
- 只有非静态的成员方法,编译看左边,运行看右边
class Demo2_Polymorphic {
public static void main(String[] args) {
Father f = new Son();
f.method(); //相当于是Father.method()
}
}
class Father {
public static void method() {
System.out.println("father static method");
}
}
class Son extends Father {
public static void method() {
System.out.println("son static method");
}
}运行结果为father static method
多态中向上转型和向下转型
class Demo3_SuperMan {
public static void main(String[] args) {
Person p = new SuperMan(); //父类引用指向子类对象,超人提升为了人,向上转型
//父类引用指向子类对象就是向上转型
System.out.println(p.name);
p.谈生意();
SuperMan sm = (SuperMan)p; //向下转型
sm.fly();
}
}
class Person {
String name = "John";
public void 谈生意() {
System.out.println("谈生意");
}
}
class SuperMan extends Person {
String name = "superMan";
public void 谈生意() {
System.out.println("谈几个亿的大单子");
}
public void fly() {
System.out.println("飞出去救人");
}
}运行结果为 John 谈几个亿的大单子 飞出去救人
- 多态的好处
- a:提高了代码的维护性(继承保证)
- b:提高了代码的扩展性(由多态保证)
- 可以当作形式参数,可以接收任意子类对象
- 多态的弊端
- 不能使用子类的特有属性和行为。
多态的好处和弊端
class Demo4_Animal {
public static void main(String[] args) {
//Cat c1 = new Cat();
//c1.eat();
method(new Cat());
method(new Dog());
//Animal a = new Cat(); 实际开发中很少在创建对象的时候用父类引用指向子类对象,直接创建子类对象更方便,可以使用子类中的特有属性和行为
}
//Cat c = new Dog();狗是一只猫,这是错误的
/*public static void method(Cat c) {
c.eat();
}
public static void method(Dog d) {
d.eat();
}*/
//如果把狗强转成猫就会出现类型转换异常,ClassCastException
public static void method(Animal a) { //当作参数的时候用多态最好,因为扩展性强
//关键字 instanceof 判断前边的引用是否是后边的数据类型
if (a instanceof Cat) {
Cat c = (Cat)a;
c.eat();
c.catchMouse();
}else if (a instanceof Dog) {
Dog d = (Dog)a;
d.eat();
d.lookHome();
}else {
a.eat();
}
}
}
class Animal {
public void eat() {
System.out.println("动物吃饭");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void lookHome() {
System.out.println("看家");
}
}抽象类的概述及其特点
- A:抽象类概述
- 抽象就是看不懂的
- B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
- abstract class 类名 {}
- public abstract void eat();
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
- c:抽象类不能实例化那么，抽象类如何实例化呢?
- 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- d:抽象类的子类
- 要么是抽象类
- 要么重写抽象类中的所有抽象方法 推荐
- a:抽象类和抽象方法必须用abstract关键字修饰
class Demo1_Abstract {
public static void main(String[] args) {
//Animal a = new Animal(); //错误: Animal是抽象的; 无法实例化
Animal a = new Cat(); //父类引用指向子类对象
a.eat();
}
}
abstract class Animal { //抽象类
public abstract void eat(); //抽象方法
public Animal() {
System.out.println("父类空参构造");
}
}
class Cat extends Animal {
public Cat() {
super();
}
public void eat() {
System.out.println("猫吃鱼");
}
}运行结果为 父类空参构造 猫吃鱼
猫狗案例
- 具体事物：猫，狗
- 共性：姓名，年龄，吃饭
- 猫的特性:抓老鼠
- 狗的特性:看家
class Test1_Animal {
public static void main(String[] args) {
Cat c = new Cat("加菲",8);
System.out.println(c.getName() + "..." + c.getAge());
c.eat();
c.catchMouse();
Dog d = new Dog("八公",30);
System.out.println(d.getName() + "..." + d.getAge());
d.eat();
d.lookHome();
}
}
abstract class Animal {
private String name; //姓名
private int age; //年龄
public Animal(){} //空参
public Animal(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;
}
public abstract void eat(); //吃饭
}
class Cat extends Animal {
public Cat(){} //空参
public Cat(String name,int age) {//有参
super(name,age);
}
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public Dog(){} //空参
public Dog(String name,int age) {//有参
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
public void lookHome() {
System.out.println("看家");
}
}
老师案例
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。
class Test2_Teacher {
public static void main(String[] args) {
BaseTeacher bt = new BaseTeacher("冯佳",18);
bt.teach();
}
}
abstract class Teacher {
private String name; //姓名
private int age; //年龄
public Teacher(){} //空参
public Teacher(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;
}
public abstract void teach();
}
class BaseTeacher extends Teacher {
public BaseTeacher(){} //空参
public BaseTeacher(String name,int age) {//有参
super(name,age);
}
public void teach() {
System.out.println("我的姓名是:" + this.getName() + ",我的年龄是:" + this.getAge() + ",讲的内容是java基础");
}
}
原文地址：https://www.cnblogs.com/albieh/p/12207407.html
时间： 2024-11-19 09:36:23