songboyao-java-继承

本文主要是介绍songboyao-java-继承，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

面向对象编程

封装
继承
多态

继承

在这里插入图片描述
多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
好处
-提高代码的复用性。

类与类之间产生了关系，是多态的前提。
使用 extends关键字进行继承
父类

public class Employee {
    String name;
    public void work(){
        System.out.println("快乐的工作着");
    }
}

子类

public class Teacher extends Employee{
    public void printName(){
        System.out.println("name = " + name);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.name = "小明";
        teacher.printName();
        teacher.work();
    }
}

继承后的特点-- 成员变量

成员变量不重名
如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

public class Fu {
    int num = 5;
}
public class ZI extends Fu{
    int num2 = 6;
    public void show(){
        System.out.println("num = " +  num);
        System.out.println("num2 = " +  num2);
    }
}
public class Test {
    public static void main(String[] args) {
        ZI zi = new ZI();
        zi.show();
    }
}

在这里插入图片描述

成员变量重名
子父类中出现了同名的成员变量时, 在子类中调用的时候调用的是子类的(就近)
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 修饰父类成员变量, 本类可以使用this

public class Fu {
    int num = 5;
}
public class ZI extends Fu {
    int num = 6;
    public void show(){
        System.out.println("Fu = " +  super.num);
        System.out.println("zi = " +  this.num);
    }
}
public class Test {
    public static void main(String[] args) {
        ZI zi = new ZI();
        zi.show();
    }
}

在这里插入图片描述
小贴士：Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu
类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

继承后的特点——成员方法

成员方法不重名
如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法,
若子类中不存在就会执行父类中相应的方法。

public class Fu {
    public void  show(){
        System.out.println("Fu  show()");
    }
}

public class ZI extends Fu {
    public void  show2(){
        System.out.println("Zi  show2()");
    }
}
public class Test {
    public static void main(String[] args) {
        ZI zi = new ZI();
        zi.show2();
        zi.show();
    }
}

成员方法重名
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(Override)。

方法重写

子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现

public class Fu {
    public void  show(){
        System.out.println("Fu  show()");
    }
}
public class ZI extends Fu {
    public void  show(){
        System.out.println("Zi  show()");
    }
}

重写的应用

public class Phone {
    public void sendMessage() {
        System.out.println("发短信");
    }

    public void call() {
        System.out.println("打电话");
    }

    public void showNum() {
        System.out.println("来电显示号码");
    }
}
package com.claire.day07.demo5;

public class NewPhone extends Phone{
    @Override
    public void showNum() {
        // 调用父类的同名方法
        super.showNum();
        System.out.println("显示来电的头像");
    }
}
public class Test {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.showNum();
    }
}

注意:

子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

继承后的特点——构造方法

首先我们要回忆两个事情，构造方法的定义格式和作用。

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super()
表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用

public class Fu {
    private int n;
    Fu(){
        System.out.println("Fu 构造");
    }
}
public class ZI extends Fu {
    ZI(){
        super(); // 先调用父类的构造方法 这里不写也会调用
        System.out.println("ZI() 构造");

    }
}
public class Test {
    public static void main(String[] args) {
        new ZI();

    }
}

父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空
间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法
在这里插入图片描述

super和this的含义

super：代表父类的存储空间标识(可以理解为父亲的引用)。
this：代表当前对象的引用(谁调用就代表谁)。

super和this的用法

1.访问成员

this.成员变量  本类的
super.成员变量  父类的
this.成员方法名()  本类的
super.成员方法名()  父类的

访问构造方法

this(...)  本类的构造方法
super(...)  父类的构造方法

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
super()和 this() 都必须是在构造方法的第一行，所以不能同时出现。

继承的特点

Java只支持单继承，不支持多继承。子类继承父类
Java支持多层继承(继承体系)。
3.

顶层父类是Object类。所有的类默认继承Object，作为父类。

子类和父类是一种相对的概念。

public boolean equals(Object obj) {
        return (this == obj);
    }

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        // instanceof  String 是否属于String类型
        if (anObject instanceof String) {
        // 强制转换为 String类型
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

抽象类

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

抽象方法：没有方法体的方法。
抽象类：包含抽象方法的类。
抽象方法:
使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体

修饰符 abstract  返回值类型  方法名 (参数列表)

抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。

public abstract  class Animal {
   public  abstract void  run();
}

抽象类的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

public abstract  class Animal {
   public  abstract void  run();

   public void sleep(){
       System.out.println("在睡觉");
   }
}
public  class Cat extends Animal{

    @Override
    public void run() {
        System.out.println("鸟悄的跑二");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.run();
        cat.sleep();
    }
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
在这里插入图片描述

抢红包

package com.weida.day02;

/**
 * @ Author     ：Eric Lee
 * @ Date       ：Created in 23:33 2022/1/28
 * @ Description：
 * @ Modified By：
 * @ Version    : 1.0
 */
public class User {
    private String userName;
    private double leftMoney;

    public User() {
    }

    public User(String userName, double leftMoney) {
        this.userName = userName;
        this.leftMoney = leftMoney;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getLeftMoney() {
        return leftMoney;
    }

    public void setLeftMoney(double leftMoney) {
        this.leftMoney = leftMoney;
    }

    @Override
    public String toString() {
        return "User{" + "userName='" + userName + '\'' + ", leftMoney=" + leftMoney + '}';
    }
}

群主

package com.weida.day02;

import java.util.ArrayList;

/**
 * @ Author     ：Eric Lee
 * @ Date       ：Created in 23:35 2022/1/28
 * @ Description：
 * @ Modified By：
 * @ Version    : 1.0
 */
public class QunZhu extends User{
    public QunZhu() {
    }

    public QunZhu(String userName, double leftMoney) {
        super(userName, leftMoney);
    }
    // 发等额红包
    public ArrayList<Double> send1(int money, int count){
        double leftMoney = this.getLeftMoney();
        if (leftMoney < money){
            return null;
        }
        // 更新
        this.setLeftMoney(leftMoney-money);
        // 等分
        money*=100;
        //每一份
        int m = money/count;
        int l = money%count;
        ArrayList<Double> list = new ArrayList<>();
        for (int i = 0; i < count-1; i++) {
            list.add(m/100.0);
        }
        if(l==0)
            list.add(m/100.0);
        else
            list.add((m+l)/100.0);
        return list;
    }
    // 发手气红包

//    public ArrayList<Double> send2(int money, int count){
//
//    }
}

成员

package com.weida.day02;

import java.util.ArrayList;
import java.util.Random;

/**
 * @ Author     ：Eric Lee
 * @ Date       ：Created in 23:44 2022/1/28
 * @ Description：
 * @ Modified By：
 * @ Version    : 1.0
 */
public class Member  extends User{
    public Member() {
    }

    public Member(String userName, double leftMoney) {
        super(userName, leftMoney);
    }
    public void open(ArrayList<Double> list){
        Random random = new Random();
        int index = random.nextInt(list.size());
        Double money = list.remove(index);
        this.setLeftMoney(money + this.getLeftMoney());
    }
}

测试

package com.weida.day02;

import java.util.ArrayList;

/**
 * @ Author     ：Eric Lee
 * @ Date       ：Created in 23:05 2022/1/28
 * @ Description：
 * @ Modified By：
 * @ Version    : 1.0
 */
public class TestRedPacket {

    public static void main(String[] args) {
        // User类   属性: username 和 leftMoney
        // QunZhu类  发红包  send(iny moeny, int count) 返回 ArrayList<Double> list
        // Member类   开红包  open (ArrayList<Double> list)  随机选一个
//        ArrayList<Object> list = new ArrayList<>();
//        list.remove()
        QunZhu qunZhu = new QunZhu("马化腾", 1000);
        ArrayList<Double> list = qunZhu.send1(100, 3);
        System.out.println(list);
        Member member1 = new Member("张三1", 10);
        Member member2 = new Member("张三2", 20);
        Member member3 = new Member("张三3", 30);
        member1.open(list);
        member2.open(list);
        member3.open(list);
        System.out.println(qunZhu);
        System.out.println(member1);
        System.out.println(member2);
        System.out.println(member3);


    }

}

这篇关于songboyao-java-继承的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

songboyao-java-继承

面向对象编程

继承

继承后的特点-- 成员变量

继承后的特点——成员方法

方法重写

继承后的特点——构造方法

super和this的含义

super和this的用法

继承的特点

抽象类

抽象类的使用

抢红包

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯