多态与继承的学习与总结

原创已于 2022-04-24 17:58:03 修改 · 280 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2022-04-17 23:13:21 首次发布

多态与继承的学习与总结

众所周知面向对象的三大特性封装，继承与多态，而其中的继承与多态更是密不可分。

继承

关键字extend

extend使用格式：

[类修饰符] class 子类名 extend 父类名 {

成员变量定义；

成员方法定义；

}

子类可以从父类处继承成员属性和成员方法(不包括被private修饰的)，子类拥有了父类所有的内容。也就是说父类有的子类都有，但是在父类中被private修饰的方法子类不能访问，但父类中被private的属性也不能直接访问但可以通过父类中的get、set方法间接访问。同时也继承了静态方法（不被priavte修饰）。但是父类的构造方法子类不能继承。

可以通过父类引用 = new 子类（）的方式创建一个子类对象，但不能子类引用 = new 父类（）的方式创建对象。因为继承中的父类与子类是is-a的关系。动物是狗但不能说狗是动物。

一个父类能够有多个子类，但一个子类只能够拥有一个父类。如果一个类没有用extend继承那么他默认继承object类。（object类是所有类的父类）

继承的好处：

解决代码重复冗余。
加强父类。
帮助实现多态，有继承才有多态。

关于继承的代码简单实操：

package com.Test;

import com.Coder.coder;
import com.Man.Man;
import com.Person.Person;
import com.Women.Women;

public class Test {
    public static void main (String[] args) {
        Man yAJ = new Man ("yaj","男","china");
        yAJ.eating ();
        yAJ.running ();
        yAJ.gameing ();
        yAJ.typeCode();
        yAJ.getName ();
        coder zhangSan = new coder ();
        zhangSan.coding ("Alibaba");
        Women Kaisa = new Women ("Kaisa","女","china");
        Kaisa.getName ();
        Kaisa.TypeCode ();
        Kaisa.eating ();
        Kaisa.gameing ();
        Kaisa.running ();
    }
}

package com.Person;

public class Person {//Man和Woman的父类，Waiterness的爷爷类。
    private String Name;
    private String Sex;
    private String Country;
    public Person() {
        this("张三","男","China");
    }
    public Person(String Name, String Sex, String Country) {
        this.Name = Name;
        this.Sex = Sex;
        this.Country = Country;
    }
    public void setName(String Name) {
        this.Name=Name;
    }
    public String getName() {
        return this.Name;
    }
    public void setSex(String Sex) {
        this.Sex = Sex;
    }
    public String getSex() {
        return this.Sex;
    }
    public void  setCountry(String Country) {
        this.Name = Country;
    }
    public String getCountry() {
        return this.Country;
    }
    public void eating(){
        System.out.println("eating");
    }
    public void running(){
        System.out.println("running");
    }
    public void gameing() {
        System.out.println ("gameing");
    }
}

package com.Man;
import com.Person.Person;
public class Man extends Person {
    public Man() {

    }
    public Man(String Name, String Sex ,String Country) {

    }
    public void typeCode() {
    System.out.println ("我在寝室打代码");
    }

}

package com.Women;

import com.Person.Person;

public class Women extends Person {
    public Women() {

    }
    public Women(String Name, String Sex, String country) {

    }
    public void TypeCode() {
        System.out.println ("我在工科楼打代码");
    }
}

package com.Coder;
import com.Man.Man;
public class coder extends Man {
    private String company;
    public void setCompany(String company) {
    this.company = company;
    }
    public String getCompany() {
        return company;
    }
    public void coding(String company) {
        System.out.println("我在"+ company +"做码农");
    }
}

结果：
请添加图片描述

多态

package com.Main;

import com.Animal.Animal;
import com.Dog.Dog;

public class Main {
    public static void main (String[] args) {
        Animal wangcai = new Dog ();
        wangcai.eating ();
    }
}

package com.Dog;

import com.Animal.Animal;

public class Dog extends Animal {
    private String food = "骨头";
    public Dog() {

    }
    public Dog(String food) {
        this.food = food;
    }
    public void eating() {
        System.out.println ("Dog吃" + food);
    }
}

package com.Animal;

public class Animal {
    private String food;
    public Animal(){

    }
    public Animal( String food){
        this.food = food;

    }
    public String getFood () {
        return food;
    }

    public void setFood (String food) {
        this.food = food;
    }
    public void eating() {
        System.out.println ("Animal吃" + food);
    }

}

结果：

上述代码简单的实现了多态。

简介：

多态：指一个方法有两种形态，编译期形态，运行期形态。

过程

1.在编译期会发生静态绑定，此时的编译器只会看这个对象的父类中有没有这种方法，有编译就能过没有就过不了。
2.在运行期发生动态绑定此时的编译器会先去看子类中有没有重写该方法，有运行子类的，没有就运行父类的。

注意

1.静态绑定是为了动态绑定服务

2.有继承才有静态绑定

 Animal wangcai = new Dog ();
/*上述是Animal父类型引用指向Dog子类型对象
其中发生了自动类型装换被称为向上转型
自动类型转换牺牲了子类特有的方法，只能有父类中有的方法，强转后可以用子类的方法*/
((Dog)wangcai).eating;
/*这是强制类型转换被称为向下转型*/

附：

基础数据类型方法同名返回值类型不同是重写但会报错

重写对引用类型向上转型是可以的，不可以向下转型，重写的方法返回值类型一定是被重写的子类的类型

书上的代码练习

package xx;
public class Student {
	private String name;
	private int score;
	public Student() {
		this("null",0);
	}
	public Student(String name,int score) {
		super();
		this.name=name;
		this.score=score;
		
	}
	public String getName() {
		return name;
	}
	public void setName() {
		this.name=name;
	}
	public int getScore() {
		return score;
	}
	public void setScore() {
		this.score=score;
	}
	public void show() {
		System.out.println(name+" "+score!);

import xx.Student;
public class TestStudent {
	public static void main(String[] ages) {
		Student student=new Student();
		Student stu1=new Student("yang",90);
		student.show();
		stu1.show();
		
	}
}

运行结果：

在这里插入图片描述