Java学习第二十九天＜方法重写＞＜多态＞＜多态细节＞＜动态绑定机制＞＜object类＞＜多态数组＞＜多态参数＞

已于 2022-03-25 20:33:51 修改
阅读量273 收藏
点赞数
文章标签： java
于 2022-03-18 23:41:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syd2820/article/details/123587012
版权

方法重写

package chapter07.D4方法重写;
​
public class Animal {
    public  void cry() {
        System.out.println("动物叫唤...");
    }
    public Object m1(){
        return null;
    }
    protected void eat(){
​
    }
}

package chapter07.D4方法重写;
​
public class Dog extends Animal{
    public  void cry() {//子类方法名，参数要和父类完全一致
        System.out.println("狗叫唤...");
    }
    public String m1(){//返回类型可以是父类下级
        return null;
    }
    public void eat(){//子类不缩小父类权限,只可扩大
​
    }
}

package chapter07.D4方法重写;
​
public class Override01 {
    public static void main(String[] args) {
​
    }
}

多态

package chapter07.D5多态;
​
public class Animal {
    private String name;
​
    public Animal(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
   /* public void setName(String name) {
        this.name = name;
    }*/
}


package chapter07.D5多态;
​
public class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }
​
}

package chapter07.D5多态;
​
public class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }
}

package chapter07.D5多态;
​
public class Food {
    private String name;
​
    public Food(String name) {
        this.name = name;
    }
​
    public String getName() {
        return name;
    }
​
  /*  public void setName(String name) {
        this.name = name;
    }*/
}

package chapter07.D5多态;
​
public class Bone extends Food{
    public Bone(String name) {
        super(name);
    }
}

package chapter07.D5多态;
​
public class Fish  extends Food {
    public Fish(String name) {
        super(name);
    }
}

package chapter07.D5多态;
​
public class Master {
    private String name;
​
    public Master(String name) {
        this.name = name;
    }
    //主人喂食物
    /*public void feed(Dog d,Bone b){//传对象
        System.out.println("主人"+name+"给"+d.getName()+"喂了"+b.getName());//父类的方法
    }
    public void feed(Cat cat,Fish fish){
        System.out.println("主人"+name+"给"+cat.getName()+"喂了"+fish.getName());
    }*/
    //简化
    public void feed(Animal animal,Food food){//父类Animal 可以接受子类对象 同理Food
        System.out.println("主人"+name+"给"+animal.getName()+"喂了"+food.getName());
    }
}

package chapter07.D5多态;
​
public class Poly01 {
    public static void main(String[] args) {
        Master tom = new Master("Tom");
        Master jack = new Master("Jack");
        Dog ww = new Dog("汪汪");
        Bone gt = new Bone("炭烤骨头");
        Animal wc = new Dog("旺财");//编译类型可以为父类，向上转型
        Bone mz = new Bone("蜜汁骨头");
        jack.feed(wc,mz);
        tom.feed(ww,gt);
​
    }
​
}

多态细节

package chapter07.D5多态.Detail;
​
public class Animal {
    String name="动物";
    int age=10;
    public void sleep(){
        System.out.println("睡");
    }
    public void run(){
        System.out.println("跑");
    }
    public void eat(){
        System.out.println("吃");
    }
    public void show(){
        System.out.println("你好");
    }
}

package chapter07.D5多态.Detail;
​
public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

package chapter07.D5多态.Detail;
​
public class PolyDetail {
    public static void main(String[] args) {
        Animal animal = new Cat();
        //animal对象可调用父类所有成员（私有除外），但不能调用子类
        //编译类型决定能调用哪些成员，执行类型决定从谁开始向上找方法
        animal.run();
​
        //若要调用Cat的catchMouse方法，要向下转型（强转）
        //语法 子类类型 引用名=（子类类型）父类引用；要求：animal原先是指向子类Cat的，animal转成Dog型就不行，因为原来不指向Dog
        Cat cat=(Cat)animal;//编译类型为子类Cat，运行类型Cat，相当于生成新的cat对象指向Cat
        cat.catchMouse();
        cat.eat();//能调用子类父类所有方法，优先自己的
    }
}

package chapter07.D5多态.Detail;
​
public class PolyDetail02 {
    public static void main(String[] args) {
       Base base = new Sub();
        System.out.println(base.count);//编译类型决定能调用哪些成员,10
        Sub sub=new Sub();
        System.out.println(sub.count);//20
    }
​
}
class Base{
    int count=10;
}
class Sub extends Base{
    int count=20;
}

package chapter07.D5多态.Detail;
​
public class PolyDetail02 {
    public static void main(String[] args) {
       Base base = new Sub();
        System.out.println(base.count);//编译类型决定能调用哪些成员,10
        Sub sub=new Sub();
        System.out.println(sub.count);//20
    }
​
}
class Base{
    int count=10;
}
class Sub extends Base{
    int count=20;
}

package chapter07.D5多态.Detail;
​
public class PolyDetail02 {
    public static void main(String[] args) {
       Base base = new Sub();
        System.out.println(base.count);//编译类型决定能调用哪些成员,10
        Sub sub=new Sub();
        System.out.println(sub.count);//20
    }
​
}
class Base{
    int count=10;
}
class Sub extends Base{
    int count=20;
}

package chapter07.D5多态.Detail;
​
public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//判断执行是否属于XX类
        System.out.println(bb instanceof AA);
        AA aa =new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);
        Object obj=new Object();
        System.out.println(obj instanceof AA);
    }
}
class AA{
​
}
class BB extends AA{
​
}

package chapter07.D5多态.Detail;
​
public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//判断执行是否属于XX类
        System.out.println(bb instanceof AA);
        AA aa =new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);
        Object obj=new Object();
        System.out.println(obj instanceof AA);
    }
}
class AA{
​
}
class BB extends AA{
​
}

package chapter07.D5多态.Detail;
​
public class PolyDetail03 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);//判断执行是否属于XX类
        System.out.println(bb instanceof AA);
        AA aa =new BB();
        System.out.println(aa instanceof AA);
        System.out.println(aa instanceof BB);
        Object obj=new Object();
        System.out.println(obj instanceof AA);
    }
}
class AA{
​
}
class BB extends AA{
​
}

动态绑定机制

package chapter07.D5多态.Detail;
​
public class DynamicBinDing {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//30 只能调用A类里的成员方法，该方法在B类相同的没有，则用A类，A类没有B类有要强转
        //两者都有用B类，A有B没有用A类，A没有B有要强转
        System.out.println(a.sum1());//20
    }
​
}
class A{
    public int i= 10;
    public int sum(){
        return getl()+10;//回到执行类的方法（动态绑定）
    }
    public int sum1(){//属性没有动态绑定，谁有就先用谁
        return i+10;
    }
    public int getl(){
        return i;
    }
}
class B extends A{
    public int i =20;
//    public int sum(){
//        return i+20;
//    }
    public int getl(){
        return i;
    }
//    public int sum1(){
//        return i+10;
//    }
}


package chapter07.D5多态.Detail;
​
public class DynamicBinDing {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//30 只能调用A类里的成员方法，该方法在B类相同的没有，则用A类，A类没有B类有要强转
        //两者都有用B类，A有B没有用A类，A没有B有要强转
        System.out.println(a.sum1());//20
    }
​
}
class A{
    public int i= 10;
    public int sum(){
        return getl()+10;//回到执行类的方法（动态绑定）
    }
    public int sum1(){//属性没有动态绑定，谁有就先用谁
        return i+10;
    }
    public int getl(){
        return i;
    }
}
class B extends A{
    public int i =20;
//    public int sum(){
//        return i+20;
//    }
    public int getl(){
        return i;
    }
//    public int sum1(){
//        return i+10;
//    }
}

package chapter07.D5多态.Detail;
​
public class DynamicBinDing {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum());//30 只能调用A类里的成员方法，该方法在B类相同的没有，则用A类，A类没有B类有要强转
        //两者都有用B类，A有B没有用A类，A没有B有要强转
        System.out.println(a.sum1());//20
    }
​
}
class A{
    public int i= 10;
    public int sum(){
        return getl()+10;//回到执行类的方法（动态绑定）
    }
    public int sum1(){//属性没有动态绑定，谁有就先用谁
        return i+10;
    }
    public int getl(){
        return i;
    }
}
class B extends A{
    public int i =20;
//    public int sum(){
//        return i+20;
//    }
    public int getl(){
        return i;
    }
//    public int sum1(){
//        return i+10;
//    }
}

object类

package chapter07.D5多态.objectpoly;
​
public class Animal {
    public void cry(){
        System.out.println("Animal cry()动物在叫唤");
    }
}

package chapter07.D5多态.objectpoly;
​
public class Cat extends Animal{
    @Override
    public void cry() {
        System.out.println("Cat cry() 小猫喵喵叫...");
    }
}

package chapter07.D5多态.objectpoly;
​
public class Dog extends Animal{
    @Override
    public void cry() {
        System.out.println("Dog cry() 小狗汪汪叫...");
    }
}

package chapter07.D5多态.objectpoly;
​
public class PolyObject {
    public static void main(String[] args) {
        //多态的特点
        Animal animal = new Dog();//编译类型animal（表面） 执行类型dog（实际）
        animal.cry();//找运行类型
        animal=new Cat();//从狗指向猫，执行类型换成狗
        animal.cry();
    }
​
}

多态数组

package chapter07.D6多态数组;
​
public class Person {
    private String name;
    private int age;
​
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String say(){
        return name+"\t"+age;
    }
​
    public String getName() {
        return name;
    }
​
    public int getAge() {
        return age;
    }
}

package chapter07.D6多态数组;
​
public class Student extends Person{
    private double score;
​
    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
​
    @Override
    public String say() {
        return "学生"+super.say()+"score="+score;
    }
    public void study(){
        System.out.println("学生"+getName()+"正在学习");
    }
}

package chapter07.D6多态数组;
​
public class Teacher extends Person{
    private double salary;
​
    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
​
​
    @Override
    public String say() {
        return "老师"+super.say()+"salary="+salary;
    }
    public void teach(){
        System.out.println("老师"+getName()+"正在授课");
    }
}

package chapter07.D6多态数组;
​
public class PloyArray {
    public static void main(String[] args) {
        Person[] persons =new Person[5];
        persons [0] = new Person("jack", 20);
        persons [1] = new Student("jack", 21,100);
        persons [2] = new Student("smith", 22,58);
        persons [3] = new Teacher("hhh", 26,800);
        persons [4] = new Teacher("kkk", 27,555);
        for (int i = 0; i < persons.length ; i++) {
            System.out.println(persons[i].say());//动态绑定机制
            //父没有子有要强转
            if (persons[i] instanceof Student){
                ((Student)persons[i]).study();
            }else if (persons[i] instanceof Teacher){
                ((Teacher)persons[i]).teach();
            }

多态参数

package chapter07.D7多态参数;
​
public class Employee {
    public String name;
    private double salary;
​
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
​
    public double getAnnual(){
        return 12*salary;
    }
​
    public String getName() {
        return name;
    }
​
    public double getSalary() {
        return salary;
    }
}

package chapter07.D7多态参数;
​
public class Manager extends Employee{
    private double bonus;
​
    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }
​
    public double getBonus() {
        return bonus;
    }
    public void manage(){
        System.out.println("经理"+getName()+"\t"+"is managing");
    }
​
    @Override
    public double getAnnual() {
        return super.getAnnual()+bonus;
    }
}

package chapter07.D7多态参数;
​
public class Worker extends Employee{
    public Worker(String name, double salary) {
        super(name, salary);
    }
    public void work(){
        System.out.println("普通员工"+getName()+"\t"+"is working");
    }
​
    @Override
    public double getAnnual() {//因为普通员工没有其他收入，直接调用父类
        return super.getAnnual();
    }
}


package chapter07.D7多态参数;
​
public class Polyparameter {
    public static void main(String[] args) {
        Worker tom = new Worker("tom", 2500);
        Manager milan = new Manager("milan", 5000,200000);
        Polyparameter polyparameter = new Polyparameter();
        polyparameter.showEmpAnnual(tom);
        polyparameter.showEmpAnnual(milan);
        polyparameter.testWork(tom);
        polyparameter.testWork(milan);
​
    }
    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
    }
    public void testWork(Employee e){
        if (e instanceof Worker){
            ((Worker) e).work();//父类没有子类有
        }else if (e instanceof Manager){
            ((Manager) e).manage();
        }
    }
}

 

syd2820
关注
Java基础语法<八> 继承 多态 抽象 反射
YiGE_snail的专栏
07-15 94
1、超类和子类 超类和子类 父类与子类 多态： 一个对象变量可以指示多种实际类型的现象称为多态 一个变量可以引用父类对象，也可以引用其子类对象，这就是多态。 不能将一个超类的引用赋给子类变量，因为调用子类方法时可能发生运行错误 子类引用可以赋给超类引用 动态绑定： 在运行时能够自动地选择哪个方法的现象称为动态绑定 是一个非常重要的特性，无需对现存的代码进行修改，就可以对程序进行扩展。 阻止继承：...
Java学习基础到深入8（方法重写、多态、多态数组、Object类方法、断点调试debug）
qq_52506860的博客
10-28 390
方法重写和重载的区别、多态、多态数组、toString、equals方法、finalize回收机制、debug
java抽象类反射_Java基础语法<八> 继承 多态 抽象 反射
weixin_39743824的博客
02-12 498
1、超类和子类超类和子类父类与子类多态：一个对象变量可以指示多种实际类型的现象称为多态一个变量可以引用父类对象，也可以引用其子类对象，这就是多态。不能将一个超类的引用赋给子类变量，因为调用子类方法时可能发生运行错误子类引用可以赋给超类引用动态绑定：在运行时能够自动地选择哪个方法的现象称为动态绑定是一个非常重要的特性，无需对现存的代码进行修改，就可以对程序进行扩展。阻止继承：final类和方法将方法...
【Java学习笔记】29 - （重要）多态 、动态绑定机制
qq_41891655的博客
10-18 117
方法或者对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承的基础之上的1.方法的多态 重写和重载都能体现多态a.say();b.say();class B{2.对象的多态（重要）1）一个对象的变异类型和运行类型可以不一致animal的变异类型是animal，运行类型是Dog2)变异类型在定义对象时，就确定了，不能改变3）运行类型是可以改变的4)编译类型看定义时 = 号的左边，运行类型看 = 的右边案例。
# 打怪升级之小白的大数据之旅(十三)＜Java基础语法之面向对象的三大特性--多态＞
不断努力的数据汪
04-08 175
打怪升级之小白的大数据之旅(十三) Java基础语法之面向对象的三大特性–多态 上次回顾:，上一章，对面向对象三大特性之一的封装进行介绍,接下来就是特性中的另一个,继承,继承是什么?没错,就是你脑海中想到的子承父业 面向对象三大特性之多态 多态是Java面向对象中的核心,怎么理解多态呢?举个栗子:我有一杯水,在100度下是液态的水,在100度以上就是气态,在0度以下就是固态.所以,我对多态的理解就是四个字: 多种形态 多态概述 Java中,多态就是父类的引用指向子类的对象 示例代码: Ainmal dog
java多态 动态连接,Java 多态与动态绑定
weixin_29201859的博客
03-11 231
class Animal {public void cry() {System.out.println("xxx");}}class Cat extends Animal {public void cry() {System.out.println("yyy");}public void bite() {System.out.println("zzz");}}public class Polymo...
java（多态、动态绑定机制、多态数组、多态参数）
weixin_63954483的博客
05-22 181
多态 1.对象的多态（可以让父类的一个引用指向一个子类对象） （1）一个对象的编译类型和运行类型可以不一致 （2）编译类型在定义对象时，就确定了，不能改变 （3）运行类型是可以变化的 （4）编译类型看定义时=号的左边，运行类型看=号的右边 例如： Animal animal = new Dog()；animal编译类型是Animal，运行类型Dog animal = new Cat()；animal的运行类型变成了Cat，编译类型仍然是Animal pub...
java 多态 与 重写_类与接口（五）java多态、方法重写、隐藏
weixin_42629522的博客
02-12 133
一、Java多态性面向对象的三大特性：封装、继承、多态。多态的类型，分为以下两种：编译时多态： 指的是 方法重载。编译时多态是在编译时确定调用处选择那个重载方法，所以也叫 静态多态，算不上真正的多态。所以，一般说的多态都是运行时的多态。运行时多态： 由于 方法重写，所以想要确定引用变量所调用的方法的入口，必须根据运行时的引用变量所指向的实例对象来确定。从而使得同一个引用变量调用同一个方法，但不同的...
Java面向对象（javaBean、继承、方法重写、多态、动态绑定）
weixin_44387652的博客
11-04 519
Java面向对象（javaBean、继承、方法重写、多态）1 javaBean 和关键字(package/import)2 继承（特征二）3 方法重写（override/overwrite）4 多态（特征三） 1 javaBean 和关键字(package/import) 1、javaBean 是 java 开发中常有的实体类，在 java 开发中符合 javaBean 类的有以下几点： (1)类的访问权限修饰符 public 的； (2)类中的属性要私有化 private； (3)类中要提供 gette
Java多态中动态绑定原理解析
08-25
"Java多态中动态绑定原理解析" Java多态中动态绑定原理解析是Java面向对象程序设计中非常重要的特性，它让程序拥有更好的可读性和可扩展性。在Java中，多态是发生在继承关系中的，需要子类重写父类的方法。父类类型...
Java 继承与多态的深入理解
08-29
继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为，使得子类具有父类的各种属性和方法。继承的特点是：在继承关系中，父类更通用、子类更具体。父类和子类需要满足is-a的关系。 为什么需要继承？...
JAVA基础——多态是如何实现的（类的继承和接口的实现，方法的重载和重写，父类引用子类对象，静态多态和动态多态）
CHB的博客
09-12 2282
众所周知，多态是面向对象语言中非常重要的一部分，多态在Java中究竟是如何实现的呢？ 什么是多态 多态顾名思义，就是同一操作作用于不同对象，有不同的解释，实现不同的效果，产生不同的执行结果。 多态的必要条件 要想实现多态，必须要满足三个必要条件 1.有类的继承关系或者实现接口 2.子类要重写父类的方法 3.父类的引用指向子类的对象 类的继承个接口的实现 类的继承 ...
Java继承与多态：Object类及其方法解析
动态绑定（也叫晚期绑定）是Java中多态的一种表现，它在运行时决定方法的调用，而不是在编译时。 `protected`和`final`是Java中的访问修饰符。`protected`使得成员在子类中可见，但不在同一包的非子类中可见。`...
Java中的多态和动态绑定
tianzhihensu的专栏
05-31 2829
1 定义 Example 动态绑定的内部机制 　1. 定义根据Core Java： 多态：一个对象变量可以指示多种实例类型的现象。 动态绑定：在运行时刻能够自动选择调用哪个方法的现象。 签名：方法名和参数列表构成一个签名 多态和动态绑定大多与继承有关，因为有了继承的出现，才有了父类与子类，然后就是随之而来的方法重写(override)，即子类重写父类的方法。另一个出现的就是子
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 378
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 682
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 470
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
SpringBoot智能物流管理系统开发指南
最新发布
2401_85762266的博客
10-18 796
在概念模式的设计中，E-R模型法是最常见的设计方法。B/S架构的运行方式是在远程的服务器上把开发的软件系统部署在远程的服务器上，在部署好软件系统之后就可以实现在任何接入互联网的电脑上访问部署好的软件系统。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 900
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值