javaSE-----继承和多态

这篇具有很好参考价值的文章主要介绍了javaSE-----继承和多态。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一.初识继承:

1.1什么是继承,为什么需要继承:

1.2继承的概念与语法:

 二.成员的访问:

2.1super关键字

2.2this和super的区别:

三.再谈初始化:

小结:

四.初识多态:

4.1多态的概念:

4.2多态的实现条件:


一.初识继承:

1.1什么是继承,为什么需要继承:

Java中使用类对现实世界中实体来进行描述,类经过实例化之后的产物对象,则可以用来表示现实中的实体,但是现实世界错综复杂,事物之间可能会存在一些关联,那在设计程序是就需要考虑。👌👌👌
那具体来说是怎么样的呢?🧐🧐🧐举个例子,比如猫狗,他们都是一个动物:
javaSE-----继承和多态,javaSE,java,开发语言

 用Java语言来描述就是:

class Cat{
    public String name;
    public int age;

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

     public void eat(){
         System.out.println(this.name+"正在吃!");
     }
 }

 class Dog{
     public String name;
     public int age;

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

     public void eat(){
         System.out.println(this.name+"正在吃!");
     }
 }
 
public class Test1 {
    public static void main(String[] args){
        Dog dog = new Dog("小黄",5);
        dog.eat();
        Cat cat = new Cat("小花",6);
        cat.eat();
    }
}

通过观察,我们可以发现,其中有诸多的地方重复,但是两个对象都从属于动物,那能否将这些共性抽取呢?面向对象思想中提出了继承的概念,专门用来进行共性抽取,实现代码复用。😀😀😀

1.2继承的概念与语法:

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。🧐🧐🧐🧐

javaSE-----继承和多态,javaSE,java,开发语言

语法实现:

修饰符 class 子类 extends 父类 {
// ... 
}

具体来说:


class Animal{
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(this.name+"正在吃!");
    }
}
//子类会继承父类的内容,所以子类无需自己定义其他内容
class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
                        //当子类继承父类之后,要先帮助父类进行成员的初始化
    }                    //此时需要通过super关键字来实现
    public void bark(){//子类中特有的方法
        System.out.println(this.name+"正在汪汪汪~");
    }
}
 class Cat extends Animal{

     public Cat(String name, int age) {
         super(name, age);//当子类继承父类之后,要先帮助父类进行成员的初始化
     }                    //此时需要通过super关键字来实现

     public void miaomiao(){//子类中特有的方法
         System.out.println(this.name+"正在喵喵叫~");
     }
 }
 //测试方法
public class Test1 {
    public static void main(String[] args){
        Dog dog = new Dog("小黄",5);
        dog.eat();//dog类中并没有定义任何成员变量,name和age属性肯定是从父类Animal中继承下来的
        dog.bark();
        System.out.println("=======================================");
        Cat cat = new Cat("小花",6);
        cat.eat();//cat类中并没有定义任何成员变量,name和age属性肯定是从父类Animal中继承下来的
        cat.miaomiao();
    }
}

输出结果:

 javaSE-----继承和多态,javaSE,java,开发语言

 注意:

  •  🐻子类会将父类中的成员变量或者成员方法继承到子类中了
  • 🐻子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承了
  • 🐻当子类继承父类之后,要先帮助父类进行成员的初始化,此时需要通过super关键字来实现。(后面介绍super关键字)

 二.成员的访问:

在继承体系中,子类将父类中的方法和字段继承下来了,那在子类中能否直接访问父类中继承下来的成员呢?🧐🧐🧐答案是可以的,这时就需要用到super关键字:

2.1super关键字

🐻super.data:访问父类的成员变量

🐻super.func():访问父类的方法

🐻super():访问父类的构造方法

class Base{
    protected int a;
    protected int b;
    protected int c;
    protected int d;

    public Base(int a, int b, int c, int d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }
    public void methodA(){
        System.out.println("父类的方法!");
    }
}
class Drived extends Base{
    int c;
    int d;

    public Drived(int a, int b, int c, int d) {
        super(a, b, c, d);//访问父类的构造方法
    }

    @Override
    public String toString() {
        return "Drived{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                ", d=" + d +
                '}';
    }

    public void method(){
        super.a = 10;
        super.b = 20;//supr.data直接访问父类成员变量
        d = 30;//访问从父类继承下来的d
        this.c = 40;
        this.a = 20;//覆盖了刚才调用的父类成员变量
    }
    public void methodB(){
        super.methodA();//调用父类的方法
        System.out.println("子类的方法!");
    }

}
public class Test1 {
    public static void main(String[] args){
        Drived d = new Drived(0,0,0,0);
        d.methodB();
        d.method();
        System.out.println(d);
    }
}

运行结果:

javaSE-----继承和多态,javaSE,java,开发语言

🐻 其中成员的访问顺序是:先看子类有没有,子类有,优先访问子类的成员,子类没有,去父类中找,父类中也没有,就报错。

2.2this和super的区别:

super this 都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的第一条语句,那他们之间有什么区别呢?
相同点:
1.😺  都是 Java 中的关键字
2.😺  只能在类的非静态方法中使用,用来访问非静态成员方法和字段
3. 😺 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在

javaSE-----继承和多态,javaSE,java,开发语言 不同点:

1. 🐻this 是当前对象的引用,当前对象即调用实例方法的对象, super 相当于是子类对象中从父类继承下来部分成员的引用
2. 🐻 在非静态成员方法中, this 用来访问本类的方法和属性, super 用来访问父类继承下来的方法和属性
3. 🐻 在构造方法中: this(...) 用于调用本类构造方法, super(...) 用于调用父类构造方法,两种调用不能同时在构造方法中出现
4. 🐻 构造方法中一定会存在 super(...) 的调用,用户没有写编译器也会增加,但是 this(...) 用户不写则没有

三.再谈初始化:

在对成员变量进行初始化的过程中,我们会用到静态代码块,实例代码块和构造方法,那在实际的运行过程中,他们的运行次序是怎样的呢?我们先看以下代码:
class Animal {
    public String name;
    public int age;
    public String color;

    static {
        System.out.println("父类的静态代码块,Animal::static{}");
    }

    {
        System.out.println("父类的实例代码块,Animal::{}");
    }

    public Animal(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("父类的构造方法,Animal(String,int,String)");
    }

    public void eat() {
        System.out.println(this.name +" 正在吃饭!");
    }
}
class Dog extends Animal{
    static {
        System.out.println("子类的静态代码块,Dog::static{}");
    }
    {
        System.out.println("子类的实例代码块,Dog::{}");
    }
    public Dog() {
        super("haha",10,"黄色");//虽然 调用了父类的构造方法 ,
        System.out.println("子类的构造方法,Dog()"); // 但是 并没有产生父类对象,此时 只是帮你进行初始化父类的成员
    }
    public void bark() {
        System.out.println(this.name +" 正在汪汪汪!");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        System.out.println("==============");
        Dog dog2 = new Dog();
    }
}
运行结果:

javaSE-----继承和多态,javaSE,java,开发语言

由此,我们可以得出(执行顺序的)结论:

1.父类的静态代码块,子类的静态代码块

2.父类的实例代码块,父类的构造方法

3.子类的实例代码块,子类的构造方法

----------》静态代码块在整个程序中只执行一次

小结:

继承的好处:
1.提高了代码的复用性(多个类相同的成员可以放在同一个类中)
2.提高了代码的维护性(如果方法的代码需要修改,只修改一处即可)
继承的坏处:
1.继承让类与类建立了关系,类的耦合性增强
2.当父类发生变化时,子类实现也不得不跟着变化,削弱了子类的独立性

四.初识多态:

4.1多态的概念:

通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态。🧐🧐🧐🧐

举例来说就是我们日常生活中的打印机,分为黑白打印和彩印,完成打印这个行为,黑白打印机和彩印机所展现的打印状态完全不同。或则上面的猫狗完成吃东西这个行为,不同的动物也会导致吃东西的状态不同。

4.2多态的实现条件:

java 中要实现多态,必须要满足如下几个条件,缺一不可:
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
4.2.1那么什么是重写?😺
重写 (override) :也称为覆盖。重写是子类对父类非静态、非 private 修饰,非 final 修饰,非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变 即外壳不变,核心重写 重写的好处在于子类可以根据需要,定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
简单总结重写就是:
1.方法名相同
2.方法的参数列表相同(个数,顺序,类型)
3.方法的返回值类型相同
4.2.2那什么是向上转型?
向上转型:实际就是创建一个子类对象,将其当成父类对象来使用
语法格式:父类类型 对象名 = new 子类类型 ()
javaSE-----继承和多态,javaSE,java,开发语言
animal 是父类类型,但可以引用一个子类对象,因为是从小范围向大范围的转换。
javaSE-----继承和多态,javaSE,java,开发语言
实现多态的代码:
class Shape {

    public void draw() {
        System.out.println("画图形!");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形!");//重写父类方法
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个圆圈!");
    }
}

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个三角形!");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画一朵花!");
    }
}

public class Test1 {

    public static void drawMaps1() {
        Rect rect = new Rect();//通过父类的引用调用重写的方法-》向上转型
        Shape shapeCycle = new Cycle();//通过父类的引用调用重写的方法-》向上转型
        Triangle triangle = new Triangle();//通过父类的引用调用重写的方法-》向上转型
        Flower flower = new Flower();//通过父类的引用调用重写的方法-》向上转型

        Shape[] shapes = {shapeCycle,rect,rect,
                shapeCycle,triangle,flower};
        for(Shape shape : shapes) {
            shape.draw();//调用同一个方法,不同的对象会有不同的结果
        }
    }
    //测试方法
    public static void main(String[] args) {
        drawMaps1();
    }
}

运行结果(这里调用了同一个方法,但是不同的对象会产生不同的结果):

javaSE-----继承和多态,javaSE,java,开发语言

小结:

1,多态是方法的多态,不是属性的多态(多态和属性无关)

2,多态的存在要有3个必要的条件:继承 | 接口的实现方法重写父类引用指向子类对象。

3,父类引用指向子类对象后,用该父类引用调用子类重写的方法( 父类类型 引用名 = new 子类类型(); ),此时多态就出现了。

结语: 写博客不仅仅是为了分享学习经历,同时这也有利于我巩固自己的知识点,总结该知识点,由于作者水平有限,对文章有任何问题的还请指出,接受大家的批评,让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注,你们的鼓励是我创作的最大动力!

javaSE-----继承和多态,javaSE,java,开发语言文章来源地址https://www.toymoban.com/news/detail-838161.html

到了这里,关于javaSE-----继承和多态的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JavaSE【继承和多态】(1)(重点:初始化、pretected封装、组合)

    继承 (inheritance) 机制 :是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特 性 的基础上进行 扩展,增加新功能 ,这样产生新的类,称 派生类 。         继承呈现了面向对象程序设计的层次结构, 体现了 由简单到复杂的认知过程。   

    2024年02月14日
    浏览(38)
  • c、c++、java、python、js对比【面向对象、过程;解释、编译语言;封装、继承、多态】

    目录 内存管理、适用 区别 C 手动内存管理:C语言没有内置的安全检查机制,容易出现内存泄漏、缓冲区溢出等安全问题。 适用于系统级编程 C++ 手动内存管理:C++需要程序员手动管理内存,包括分配和释放内存,这可能导致内存泄漏和指针错误。 适用于游戏引擎和系统级编

    2024年02月08日
    浏览(76)
  • 【Java0基础学Java第八颗】 -- 继承与多态 -- 多态

    通俗来说就是多种形态, 具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态 。 就比如打印机,彩色打印机和黑白打印机,打印出的效果一个是彩色,一个是黑白。 即: 同一件事情,发生在不同对象身上,就会产生不同的结果 。 在Java中要实现多态,

    2024年02月04日
    浏览(44)
  • (java)继承和多态 (详解)

    目录 1 继承 1.1为什么需要继承 1.2 继承概念 1.3 继承的语法 1.4 父类成员访问  1.4.1 子类中访问父类的成员变量 1.4.2 子类中访问父类的成员方法   1.5 super 1.6 子类构造方法 1.7 super和this 1.7.1 this 1.7.2 super和this  1.8 再谈初始化 1.9 继承方式 1.10 继承与组合 2 多态 2.1 多态

    2024年02月03日
    浏览(41)
  • Java之继承和多态

    1.  为什么需要继承 先看下代码 // Dog.java public class Dog { string name ; int age ; float weight ; public void eat (){ System . out . println ( name + \\\" 正在吃饭 \\\" ); } public void sleep (){ System . out . println ( name + \\\" 正在睡觉 \\\" ); } void Bark (){ System . out . println ( name + \\\" 汪汪汪 ~~~\\\" ); } } // Cat.Java public class Ca

    2024年04月23日
    浏览(32)
  • Java三大特性:封装、继承、多态

    高内聚,低耦合 高内聚:类内部操作自己完成,不允许外部干涉。 低耦合:仅暴露少量的方法给外部使用。 封装(数据的隐藏) 通常应禁止直接访问一个对象中数据的实际表达,而应该通过操作接口来访问,这称为信息的隐藏。 封装的特点 1.提高程序的安全性,保护数据

    2024年03月21日
    浏览(48)
  • Java 封装 继承 多态(深入理解)

    登神长阶 第二阶 封装 继承 多态 🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀 目录 🍒一.面向对象编程的三大特性 🍍二.封装 🧉1.定义及其作用  🥝2.访问限定符 🫛3.封装扩展 包(package) 🥕3.1.定义及其作用  🥦 3.2.导入包的类 🍔3.3.自定义包 🌯

    2024年03月11日
    浏览(98)
  • Java面向对象 - 封装、继承和多态

    目录 第1关:什么是封装,如何使用封装 第2关:什么是继承,怎样使用继承 第3关:super的使用 第4关:方法的重写与重载 第5关:抽象类 第6关:final的理解与使用 第7关:接口 第8关:什么是多态,怎么使用多态 Java_Educoder

    2024年02月07日
    浏览(80)
  • Java系列——封装、继承、多态初了解

    目录 一、前言 二、封装 1.什么是封装?   2.封装的特点 3.封装的使用 三、继承 1.什么是继承? 2.继承的特点 3.继承的优点 4.继承的使用  4.1 继承的格式  4.2 继承的演示 4.3 成员变量 4.4 成员方法 4.5 构造方法 五、多态 1.什么是多态? 2.多态的特点 3.多态的使用  4.引用类型

    2024年02月08日
    浏览(43)
  • 【Java初阶(六)上】封装 继承 多态

    ❣博主主页: 33的博客❣ ▶文章专栏分类: Java从入门到精通◀ 🚚我的代码仓库: 33的代码仓库🚚 对于面向对象程序三大特性:封装、继承、多态。这篇文章将会详细讲解到如何实现封装、继承、多态,以及具体的应用。 本章重点 掌握封装的概念,如何实现封装,包的概念,继

    2024年04月09日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包