Java实训第四天课堂内容记录

一、继承

发生在父子之间  父类（基类）

定义：公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。（在Java语言中使用extends（扩展）关键字来表示继承关系） x是extends的简写。Javax代表扩展的意思。

优点：提高了代码的复用性，可维护性以及拓展性。

注意：

（1）子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能被直接访问。

（2）无论使用何种方式构造子类的对象时，都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码：super（）的效果。

通过super，可以访问父类的构造方法（必须写在子类构造方法的第一行）

通过super，可以访问父类的属性

通过super，可以访问父类的方法

（3）使用继承必须满足逻辑关系：子类is a 父类，也就是不能滥用继承

（4）Java语言中只支持单继承，不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

二、方法的重写（Override）

方法的重载（Overload）：要求方法的名称相同，参数的类型，个数，顺序不同

（1）基本概念：当从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式叫做方法的重写。

（2）重写的原则：

要求方法名相同、参数列表相同以及返回值类型相同，从jdk1.5开始允许返回子类类型

要求方法的访问权限不能变小，可以相同或者变大

要求方法不能抛出更大的异常（异常机制）

声明为static和private的方法不能被重写，但能够被再次声明

***方法的重写和重载的区别

三、访问权限

常用的访问权限

 四、抽象类

（1）概念：抽象类必须使用abstract class声明

***一个抽象类中可以没有抽象方法，可以有构造方法，普通方法。但是抽象方法必须写在抽象类或者接口中。

（2）抽象方法：只声明而未实现的方法称为抽象方法。未实现是指：没有“（）”方法体，抽象方法必须使用abstract关键字声明。（就是用来被继承的 ）

格式：

***拥有抽象方法的类，才是实际意义上的类。

（3）在抽象类的使用中的原则

1.抽象类本身是不能被实例化操作的，即：不能直接使用关键字new完成。

2.一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须重写抽象类中的全部抽象方法。

3.抽象类能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

4.抽象类不能使用final声明，因为final属修饰的类是不能有子类的，而抽象类必须有子类才有意义。

（4）抽象类和普通类的区别

五、多态

概念：多态主要是指同一种事物表现出来的多种形态

语法格式：父类类型 引用变量名 = new 子类类型（）；//父类型的引用指向子类型的对象【多态的核心】

多态的效果：

***普通的成员方法，属于对象层级，静态方法属于类层级

引用数据类型之间的转化:

实际意义：

多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。

六、final关键字

1.用于修饰属性、变量（表示变量变为了常量，无法再对其再次进行赋值）

final修饰的局部变量，只能赋值一次（可以先声明后赋值）

final修饰的成员变量时，必须再声明时赋值。

2.用于修饰类

final修饰类，不可以被继承

3.用于修饰方法

final修饰方法，不允许被子类重写

全局常量（public static final）

全局常量的命名规范：由一个或多个单词组成，单词和单词之间必须使用下划线隔开，单词中所有的字母大写。

七、接口

1.概念

这种思想是定义与实现的分离。

2. 优点

（1）降低程序的耦合性

（2）易于程序的扩展

（3）有利于程序的维护

3.简写

4.接口的实现

接口可以多实现

class 子类 extends 父类 implements 父接口1，父接口2....{

}

5.接口的继承

接口因为都是抽象部分，不存在具体的实现，所以允许多继承

interface C extends A，B{

}

***如果一个接口要想使用，必须依靠子类。子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

八、接口和抽象类的区别

九、代码部分

package FourDay.account;

/**
 * @author zcl
 * @Description 自定义抽象类Account实现封装，特征：账户余额（balance）
 * 在该类中提供一个计算利息并返回的抽象方法
 */
public abstract class Account {
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }

    public Account() {
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public abstract double getInterest(double index, double time);
}

 

/**
 * @author zcl
 * @Description 自定义FixedAccou类继承Account类并重写抽象方法
 */
public class FixedAccount extends Account {

    public FixedAccount(double balance) {
        super(balance);
    }

    public FixedAccount() {
    }

    @Override
    public double getInterest(double index, double time) {
        return getBalance() * index * time;
    }
}

/**
 * @Author ZhaoChunLi
 * @Description 利息 = 本金 * 利率 * 存款期限
 * 要求在main方法中使用多态方式构造对象并存入1000元，计算利息后打印出来（其中利率0.003，时间1年）
 * @Date Created in 2024/1/30 22:48
 */
public class AccountTest {
    public static void main(String[] args) {
        Account account = new FixedAccount(1000);
        System.out.println("本金：" + account.getBalance() + "，利息为：" + account.getInterest(0.003, 1));
    }
}

 

 

public class Animal {
    private String name;
    private String color;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

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

    public Animal() {
    }

    public void show() {
        System.out.println("我的名字叫做：" + getName() + ", 我的颜色是：" + getColor());
    }
}

 

public class Dog extends Animal {
    private int teethNumber;

    @Override
    public void show() {
        System.out.println("我叫：" + getName() + "，颜色是：" + getColor() + "，牙齿数量是：" + getTeethNumber());
    }

    public Dog() {
    }

    public Dog(String name, String color, int teethNumber) {
        super(name, color);
        this.teethNumber = teethNumber;
    }

    public Dog(int teethNumber) {
        this.teethNumber = teethNumber;
    }

    public int getTeethNumber() {
        return teethNumber;
    }

    public void setTeethNumber(int teethNumber) {
        this.teethNumber = teethNumber;
    }
}

 

public class DogTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
        Dog dog1 = new Dog("压力", "粉色", 1);
        dog1.show();
    }
}

public class Chinese implements Hunter {

    @Override
    public void hunt() {
        System.out.println("抓到一只小白兔");
    }

    @Override
    public void running() {
        System.out.println("正在全力的奔跑");
    }
}

public interface Hunter extends Runner {
    void hunt();
}

public interface Runner {
    void running();

}

public class ChineseTest {
    public static void main(String[] args) {
        //接口类型的引用指向实现类的对象，形成多态
        Runner runner = new Chinese();
        runner.running();
        Hunter hunter = new Chinese();
        hunter.hunt();
    }
}

 

 

public class Circle extends Shape {

    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle() {
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public Circle(int x, int y, double radius) {
        super(x, y);
        this.radius = radius;
    }

    @Override
    public void show() {
        System.out.println("x = " + getX() + ",y = " + getY() + ",radius = " + getRadius());
    }
}

 

public class Rect extends Shape {

    private int length;
    private int width;

    public Rect() {
    }

    public Rect(int length, int width) {
        this.length = length;
        this.width = width;
    }

    public Rect(int x, int y, int length, int width) {
        super(x, y);
        this.length = length;
        this.width = width;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    @Override
    public void show() {
        System.out.println("x = " + getX() + ",y = " + getY() + ",length = " + getLength() + ",width = " + getWidth());
    }
}

 

public class Shape {
    private int x;
    private int y;

    public void show() {
        System.out.println("x = " + getX() + ",y = " + getY());
    }

    public Shape() {
    }

    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

 

/**
 * @author ZCL
 * @Description:自定义ShapeTest类，自定义成员方法实现既能打印矩形又能打印圆形的方法并调用
 */
public class ShapeTest {

    public static void printRect(Rect rect) {//形参
        rect.show();
    }
    public static void printCircle(Circle circle) {
        circle.show();
    }
    //既能打印矩形又能打印圆形!!!!!!!!
    public static void printShape(Shape shape) {
        shape.show();//调用父类型独有的
    }
    public static void main(String[] args) {//static修饰的方法只能调用静态的方法
        /*Shape shape = new Shape(3,4);
        shape.show();
        Rect rect = new Rect(1,2,3,4);
        rect.show();
        Circle circle = new Circle(1,2,4);
        circle.show();、

        printRect(new Rect(1,2,3,4));
        printCircle(new Circle(1,2,4));

        //多态：父类型的引用 引用变量名 = new 子类类型（）；
        Shape shape = new Rect(1,2,3,4);
        shape.show();
        Shape shape1 = new Circle(1,2,4);
        shape1.show();*/

        printShape(new Shape(3, 4));
        printShape(new Rect(1,2,3,4));
        printShape(new Circle(1,2,4));
    }
}