• Java基础-day05

    面向对象编程

    • 封装
    • 继承
    • 多态

    继承

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

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

    • 类与类之间产生了关系，是多态的前提。
      使用 extends关键字进行继承
      父类
    public class Employee {
    String name;
    public void work(){
        System.out.println("快乐的工作着");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    子类

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

    • 1
    • 2
    • 3
    • 4
    • 5

    测试

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

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

    • 成员变量不重名
      如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。
    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();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述

    • 成员变量重名
      子父类中出现了同名的成员变量时, 在子类中调用的时候调用的是子类的(就近)
      子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 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();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述
    小贴士：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();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 成员方法重名
      如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写(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()");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    重写的应用

    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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    注意:

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

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

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

    1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
    2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个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();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

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

    super和this的含义

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

    super和this的用法

    1.访问成员

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

    • 1
    • 2
    • 3
    • 4
    1. 访问构造方法
    this(...)  本类的构造方法
super(...)  父类的构造方法

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

    继承的特点

    1. Java只支持单继承，不支持多继承。 子类继承父类
      在这里插入图片描述
    2. Java支持多层继承(继承体系)。
      3.在这里插入图片描述

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

    • 子类和父类是一种相对的概念。
    public boolean equals(Object obj) {
        return (this == obj);
    }

    • 1
    • 2
    • 3
    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;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    • 1
    • 2
    • 3

    抽象类

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

    • 抽象方法：没有方法体的方法。
    • 抽象类：包含抽象方法的类。
      抽象方法:
      使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体
    修饰符 abstract  返回值类型  方法名 (参数列表)

    • 1

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

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

    • 1
    • 2
    • 3

    抽象类的使用

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

    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();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

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

    抢红包

    
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 + '}';
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    群主

    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 send2(int money, int count){
//
//    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    成员

    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());
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    测试

    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 list
        // Member类   开红包  open (ArrayList list)  随机选一个
//        ArrayList 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);


    }

}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    
                
                    
                

                
  • 

                    相关阅读:
    
                    
跳槽字节跳动社招Java面试分享                            
    
Golang协程-通道方向                            
    
C++11中的一些新特性以及代码详解                            
    
微软 AI 量化投资平台 Qlib 体验                            
    
给ShardingSphere提了个PR                            
    
二,手机硬件参数介绍和校验算法                            
    
【沁恒单片机】MounRiver开发工具官方Demo迁移的处理以及Symbol could not be resolved的处理                            
    
数一独有：多元函数积分学中的基本公式及其应用                            
    
HR人才测评，什么是协调能力？如何提高协调能力？                            
    
HTML+CSS美食静态网页设计——简单牛排美食餐饮(9个页面)公司网站模板企业网站实现                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/qq_39276337/article/details/126135017
                
    •