首页 > 编程语言> 文章详细

songboyao-java-继承

2022-01-28 23:59:07 阅读：107 来源： 互联网

标签：java 继承子类 void songboyao class println 父类 public

面向对象编程

封装
继承
多态

继承

在这里插入图片描述
多个类可以称为子类，单独那一个类称为父类、超类（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);


    }

}

标签：java,继承,子类,void,songboyao,class,println,父类,public
来源： https://blog.csdn.net/qq_39276337/article/details/122737398

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9