Java基础补习---Day 09

一、继承

（一）概述

1、让类与类之间产生联系，子父级关系

2、实现继承需要使用关键字：extends，含义：继承、增加、扩展

3、父类：被继承的类，别称：超类、根类、基类

4、子类：用于继承的类，别称：派生类

5、格式

class 子类 extends 父类 {

}

public class Demo01_Extends {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.name);
        p.test();
        Student s = new Student();
        System.out.println(s.name);
        s.test();
    }
}
//父类
class Person {
    String name;
    public void test() {
        System.out.println("父类方法执行了");
    }
}
//子类
class Student extends Person {
}

（二）继承的好处和弊端

1、好处：

（1）提高了代码的复用性

（2）提高了代码的可维护性

2、弊端：

（1）提高了代码的耦合度

（2）耦合度：代码和代码之间的关联程度

3、开发原则：高内聚，低耦合，代码复用性高

（三）继承的注意事项

1、私有成员变量不能被继承，但是set、get方法可以被继承，可以通过set、get方法访问父类的私有属性

2、父类的构造方法不能被继承

3、继承的设计：要符合子类 is a 父类的逻辑

（1）程序员类：姓名， 年龄， 工号， 工资；方法：工作

（2）项目经理类：姓名， 年龄， 工号， 工资， 奖金；方法：工作（不成立）

4、父类中放的是所有子类的共性，子类中除了父类继承来的共性，还有自己的个性

public class Demo01_Extends {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.getName());
        Student s = new Student();
        System.out.println(s.getName() + s.getStuId());
    }
}
//父类
class Person {
    private String name;
    private int age;
    private String sex;
    //alt + insert
    //alt + insert 选择第一个，在选最上面 ctrl + 回车
    public Person() {
    }
    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Person(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}
//子类
class Student extends Person {
/**
* 如果子类有自己的属性，在创建构造方法的时候需要注意，子类满参，子父类满参，子父类空参
* 如果构造方法又特殊需要，先去筛选父类构造的属性，再去筛选子类构造的属性
*
* 如果子类有自己的属性，那么应该在子类中为自己的私有成员变量提供对应的set、get方法
*/
    private String stuId;
    public Student() {
    }
    public Student(String stuId) {
        this.stuId = stuId;
    }
    public Student(String name, int age, String sex, String stuId) {
        super(name, age, sex);
        this.stuId = stuId;
    }
    public Student(String name, String sex, String stuId) {
        super(name, sex);
        this.stuId = stuId;
    }
    public String getStuId() {
        return stuId;
    }
    public void setStuId(String stuId) {
        this.stuId = stuId;
    }
}

（四）继承的特点

1、Java支持单继承、多层继承；不支持多继承

2、单继承：一个子类只能继承一个父类

3、多层继承：C继承B，B继承A

4、多继承：一个子类不能同时继承多个父类

5、不支持多继承原因：如果多个父类中含有相同的方法，子类去使用的时候就不知道调用的是那个方法了

public class Demo02_Extends {
}
//多层继承
class A {
    public void test() {
        System.out.println("A的方法执行了");
    }
}
class B extends A {
    public void test() {
        System.out.println("B的方法执行了");
    }
}
class C extends B {
    public void test() {
        System.out.println("C的方法执行了");
    }
}
// 多继承
// class D extends A, B, C {}

（五）继承中成员变量的关系

1、在子父类中如果没有定义重名的变量，子类就可以直接使用父类继承来的变量

2、如果定义了重名的变量，子类对象就只使用子类中的成员变量，就近原则

3、如果一个类没有明确说明继承了那个类，就默认继承Object类

public class Demo03_Field {
    public static void main(String[] args) {
        Son son = new Son();
        son.show();
}
}
class Father {
    String name = "父类";
}
class Son extends Father {
    String name = "子类";
    public void show() {
        System.out.println(name);
    }
    public void test() {
        //这里的name不能访问到
        String name = "test";
    }
}

（六）this和super

1、this关键字：当前类型当前对象的引用

2、super关键字：当前对象父类的引用

3、访问内容

（1）可以访问成员变量

this.变量名

super.变量名

（2）可以访问成员方法

this.方法名

super.方法名

（3）可以访问构造方法

this();访问本类中的其它构造方法

super();访问父类的指定构造方法

4、为父类私有属性赋值

（1）子类继承父类中的set、get方法，通过get、set方法访问父类私有属性

（2）创建子类对象的时候调用子类构造方法，子类构造方法中又调用父类构造方法，父类构造方法再去给自己的私有属性进行赋值

5、注意

（1）子类空参构造中省略了调用父类的空参构造的方法【super();】

（2）在构造方法中，this和super不能共存，在调用构造方法的时候不能共存

（3）在成员方法中不能使用this或者super调用构造方法，因为构造方法是自动调用，如果手动调用会违背原则

public class Demo04_ThisAndSuper {
}
class Person01 {
    String name = "父类变量";
    public void show() { }
    public Person01() {
    }
    public Person01(String name) {
        this.name = name;
    }
}
class Student01 extends Person01 {
    public void test01() {}
    public Student01() {
        //super在构造方法中可以调用父类构造
        super();
    }
    public Student01(String name) {
        super(name);
        //this在构造方法可以调用其它构造方法，但是在构造方法中this和super都必须放在第一行
        //所以，this和super在构造中不能共存
        //this();
    }
    public void test() {
        //super可以访问成员变量
        System.out.println(super.name);
        //super可以访问成员方法
        super.show();
        //this可以访问成员方法
        this.test01();
        //构造方法不能在成员方法中调用
        //this.Student01();
        //super.Person01();
    }
}

（七）继承中成员方法的关系

1、在子父类中，出现了不同名的方法，子类对象调用方法时，子类中如果有就执行子类的方法，父类中如果有就执行父类的方法

2、在子父类中，出现了同名的方法，子类对象调用方法时，只会执行子类的方法，不执行父类方法

3、结合2中的现象，我们一般需要在子类中修改父类的逻辑，就按照子类的逻辑进行执行

4、3中的操作叫做方法的重写

（1）重载：在同一个类中，方法名称相同，参数列表不同，与返回值类型无关；参数列表不同分为：顺序、类型、个数

（2）重写：在子父类中，方法名称相同，参数列表相同，与返回值类型有关

（3）与返回值类型有关：要么保持一致，要么父类返回值类型是子类返回值类型的父类；不能是子类，更不能是无关类

（4）@Override：注解；用于检测是否符合重写的语法

（5）权限修饰符：要么保持一致，要么父类方法的修饰符范围比子类方法的修饰符范围小；不能子类方法修饰符比父类方法修饰符范围小，私有方法不能被重写，静态方法不能被重写

public class Demo05_Method {
    public static void main(String[] args) {
        Benz b = new Benz();
        b.test();
    }
}
class Car {
    Object test() {
    System.out.println("父类方法执行了");
    return null;
}
}
class Benz extends Car {
    /**
    * 方法的重写
    * 返回值类型：要么保持一致，要么父类返回值类型是子类返回值类型的父类；
    * 不能是子类，更不能是无关类
    * 权限修饰符：要么保持一致，要么父类方法的修饰符范围比子类方法的修饰符范围小
    * 不能子类方法修饰符比父类方法修饰符范围小，私有方法不能被重写
    */
    @Override
    public String test() {
        System.out.println("子类方法执行了");
    return null;
    }
}

二、Date

1、该类的对象用于表示一个特定的瞬间，精确到毫秒值，根据构造方法的不同可以创建不同的瞬间

2、构造方法：

（1）Date()：表示创建对象的那一刹那瞬间

（2）Date(long date)：表示传入毫秒值的时间，是从1970年1月1日0时0分0秒开始计算，起源于英国本初子午线

3、成员方法

（1）getTime()：获取Date对象表示的时间的毫秒值

（2）setTime(long time)：将调用者对象的毫秒值设置为指定值

import java.util.Date;
public class Demo06_Date {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);//Thu Mar 23 13:26:52 CST 2023
        System.out.println(d.getTime());//1679549283459
        d.setTime(10000);
        System.out.println(d);
        Date d1 = new Date(1000);
        System.out.println(d1);//Thu Jan 01 08:00:01 CST 1970
    }
}

三、DateFormat

1、直接打印Date得到的日期格式不方便阅读，我们想要按照自己的格式进行日期的输出，需要使用将Date与字符串之间互相转化的方法

2、DateFormat是一个抽象类，无法创建对象，将来可以使用它的子类创建对象调用它的方法

3、已知实现子类SimpleDateFormat

4、常用方法：

（1）format(Date date)：将Date时间日期转为字符串

（2）parse(String source)：将字符串转为Date类型

四、SimpleDateFormat

（一）使用

1、SimpleDateFormat是DateFormat的子实现类，可以调用父类中的方法

2、构造方法：

（1）SimpleDateFormat()：使用默认的格式解析时间对象【23-3-23 下午1:51】

（2）SimpleDateFormat(String pattern)：使用给定格式进行解析时间对象

3、常用模式

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo07_SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
    //原料 String -> Date
        String time = "2023-03-23 13:51";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Date date = sdf.parse(time);
        System.out.println(date);
        //Date -> String
        SimpleDateFormat sdf2 = new SimpleDateFormat("yy-MM-dd");
        String str = sdf2.format(date);
        System.out.println(str);
    }
    private static void test() {
        //(1) format(Date date): 将Date时间日期转为字符串
        //(2) parse(String source):将字符串转为Date类型
        //原料
        Date date = new Date();
        //加工厂
        SimpleDateFormat sdf = new SimpleDateFormat();
        //format加工厂的机器 产出的String就是结果
        String time = sdf.format(date);
        System.out.println(time);
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS");
        String str = sdf1.format(date);
        System.out.println(str);
    }
}

（二）练习

键盘录入自己的生日，计算一下今天是自己来到这个世界的第几天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Demo08_Exercise {
    //键盘录入自己的生日，计算一下今天是自己来到这个世界的第几天
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入你的生日，例如：2000-2-4");
        String birthday = sc.nextLine();
        //创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //将字符串转为date格式
        Date date = sdf.parse(birthday);
        //获取出生日期的毫秒值
        long birTime = date.getTime();
        //获取今天的毫秒值
        Date today = new Date();
        long todayTime = today.getTime();
        int day = (int) ((todayTime - birTime) / 1000 / 60 / 60 / 24);
        System.out.println("今天是你出生的第" + day + "天");
    }
}

五、权限修饰符

修饰符	本类	同一个包中的类	子类	其他类
publi	√	√	√	√
protected	√	√	√
默认	√	√
private	√