Java基础学习

封装和继承

Java基础学习---点击进入学习

1.封装

封装

属性私有：将所有的属性使用private关键字修饰 表示只能在本类中访问

方法公开：针对每一个属性编写一对方法 分别用于实现属性的赋值setter 和 取值getter

​ getter方法格式：get + 属性名首字母大写(){} 不需要参数 但要有返回值

​ setter方法格式：set + 属性名首字母大写(){} 不需要有返回值 但要有参数

高内聚：一个类中描述的属性和方法，应该直接与本类产生关联关系，不应该间接关联，或者没有关联

低耦合：

企鹅类

属性：名字 健康值 亲密值 性别

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 9:27
 *  封装
 *      属性私有：将所有的属性使用private关键字修饰 表示只能在本类中访问
 *      方法公开：针对每一个属性编写一对方法 分别用于实现属性的赋值setter 和 取值getter
 *          getter方法格式：get + 属性名首字母大写(){}   不需要参数 但要有返回值
 *          setter方法格式：set + 属性名首字母大写(){}   不需要有返回值 但要有参数
 *
 *  高内聚：一个类中描述的属性和方法，应该直接与本类产生关联关系，不应该间接关联，或者没有关联
 *  低耦合：
 *
 *
 *  企鹅类
 *      属性：名字 健康值 亲密值 性别
 */
public class Penguin {
    private String name;

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

    public String getName(){
        return name;
    }

    private int health;

    public void setHealth(int health){
        if(health >= 0 && health <= 100){
            this.health = health;
        }else{
            System.out.println("健康值赋值错误，将使用默认值：50");
            this.health = 50;
        }
    }

    public int getHealth(){
        return health;
    }

    private int love;

    public void setLove(int love){
        if(love >= 0 && love <= 100){
            this.love = love;
        }else{
            System.out.println("亲密值赋值错误，将使用默认值：50");
            this.love = 50;
        }
    }

    public int getLove(){
        return love;
    }

    private char sex;

    public void setSex(char sex){
        if(sex == '雌' || sex == '雄'){
            this.sex = sex;
        }else{
            System.out.println("性别赋值错误，将使用默认值：雄");
            this.sex = '雄';
        }
    }

    public char getSex(){
        return sex;
    }


    /**
     *  此方法为测试企鹅类的方法 实际开发中 不会直接书写在企鹅类中
     * @param args
     */
    public static void main(String[] args) {
        Penguin penguin = new Penguin();

        penguin.name = "大白";
        penguin.health = -1000;
        penguin.love = -888;
        penguin.sex = '男';


        System.out.println(penguin.name);
        System.out.println(penguin.health);
        System.out.println(penguin.love);
        System.out.println(penguin.sex);

    }




}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 9:39
 *  企鹅测试类
 */
public class TestPenguin {
    public static void main(String[] args) {
        Penguin penguin = new Penguin();

//        penguin.name = "大白";
//        penguin.health = -1000;
//        penguin.love = -888;
//        penguin.sex = '男';

        penguin.setName("大白");
        penguin.setHealth(-1000);
        penguin.setLove(-888);
        penguin.setSex('男');

//        System.out.println(penguin.name);
//        System.out.println(penguin.health);
//        System.out.println(penguin.love);
//        System.out.println(penguin.sex);

        System.out.println(penguin.getName());
        System.out.println(penguin.getSex());
        System.out.println(penguin.getHealth());
        System.out.println(penguin.getLove());

    }
}

2.封装的好处

便于使用者正确使用系统，防止错误修改属性

降低了构建大型系统的风险

提高程序的可重用性

降低程序之间的耦合度

3.访问权限修饰符

3.1 类的访问权限修饰符

public ： 公开的 本项目中任何位置都可以访问

默认不写：包级别的访问权限 只有在同包内才可以访问

3.2 类成员的访问权限修饰符

private:本类可以访问

默认不写：本类、本包可以访问

protected：本类、本包、以及子类

public：任何位置

4.super关键字

4.1 访问属性

super关键字：可以访问父类访问权限允许的信息

属性：super.属性名

我们在子类中编写全参构造方法，子类只有单独的属性，共有的三个属性书写在父类中，我们可以通过super关键字进行访问。

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:13
 *  宠物类父类
 *  父类中书写共有的属性和方法
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;
    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public void print(){
        System.out.println("宠物的名字是：" + name);
        System.out.println("宠物的健康值是：" + health);
        System.out.println("宠物的亲密值是：" + love);
    }
}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:07
 *  狗狗类
 *      属性：品种
 *      行为：打印狗狗信息
 *
 */
public class Dog extends Pet {
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog(){}

    public Dog(String name,int health,int love,String strain){
        this.strain = strain;
        super.name = name;
        super.health = health;
        super.love = love;
    }

    /**
     *  用于打印狗狗信息
     */
    public void printDog(){
        this.print(); // super.print()   print()
        System.out.println("狗狗的品种是：" + strain);
    }


}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 15:19
 *  猫咪类
 *      属性：毛发颜色
 */
public class Cat extends Pet {
    private String furColor;

    public String getFurColor() {
        return furColor;
    }

    public void setFurColor(String furColor) {
        this.furColor = furColor;
    }
    public Cat(){}

    public Cat(String name,int health,int love,String furColor){
        this.furColor = furColor;
        super.name = name;
        super.health = health;
        super.love = love;
    }


    public void printCat(){
        System.out.println("猫咪的毛发颜色是：" + furColor);
        print();
    }

}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:16
     *  super关键字：可以访问父类访问权限的信息
     *      属性：super.属性名
 *      方法：super.方法名()
 *      构造方法：super()
 */
public class TestPet {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄", 100, 100, "拉不拉多");
        dog.print();
        System.out.println("狗狗的品种是：" + dog.getStrain());

        System.out.println("-----------------------------------------------");

        Penguin penguin = new Penguin("大白", 100, 100, "雄性");
        penguin.print();
        System.out.println("企鹅的性别是：" + penguin.getSex());

        System.out.println("-----------------------------------------------");

        Cat cat = new Cat("小红", 100, 100, "绿色");
        cat.print();
        System.out.println("猫咪的毛发颜色是：" + cat.getFurColor());


    }
}

4.2 访问方法

方法：super.方法名()

我们在子类中编写方法用于打印宠物信息，而父类中已经实现了共有的三个信息的打印，所以我们可以在子类中调用父类的方法，再加上子类的一句打印，实现组合的效果。

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:13
 *  宠物类父类
 *  父类中书写共有的属性和方法
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;
    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public void print(){
        System.out.println("宠物的名字是：" + name);
        System.out.println("宠物的健康值是：" + health);
        System.out.println("宠物的亲密值是：" + love);
    }
}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:07
 *  狗狗类
 *      属性：品种
 *      行为：打印狗狗信息
 *
 */
public class Dog extends Pet {
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog(){}

    public Dog(String name,int health,int love,String strain){
        this.strain = strain;
        super.name = name;
        super.health = health;
        super.love = love;
    }

    /**
     *  用于打印狗狗信息
     */
    public void printDog(){
        this.print(); // super.print()   print()
        System.out.println("狗狗的品种是：" + strain);
    }


}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:10
 *  企鹅类
 *      属性：性别
 *      行为：打印企鹅信息
 *
 *  alt + insert 生成封装的方法
 */
public class Penguin extends Pet {
    private String sex;
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Penguin(){}

    public Penguin(String name,int health,int love,String sex){
        this.sex = sex;
        super.name = name;
        super.health = health;
        super.love = love;
    }

    public void printPenguin(){
        System.out.println("企鹅的性别是：" + sex);
        super.print();
    }

}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 15:27
 *  给各个宠物子类添加打印方法
 */
public class TestPetAddMethod {
    public static void main(String[] args) {
        Dog dog = new Dog("大黄", 100, 100, "拉不拉多");
        dog.printDog();

        System.out.println("-----------------------------------------------");

        Penguin penguin = new Penguin("大白", 100, 100, "雄性");
        penguin.printPenguin();

        System.out.println("-----------------------------------------------");

        Cat cat = new Cat("小红", 100, 100, "绿色");
        cat.printCat();
    }
}

4.3 访问构造方法

构造方法：super()

父类中书写了全参构造方法，子类中可以通过super关键字调用父类的构造方法，以实现代码的重用效果。

访问父类的构造方法，必须在子类构造方法的第一句。

父子类之间的构造方法

子类的每一个构造方法，默认访问父类的无参构造方法，除非显式的访问父类有参构造方法

总结：子类的任何一个构造方法都必须访问父类的无参构造 或者 有参构造

为什么子类的构造方法都要访问父类的构造方法？

​ 调用父类的构造方法是为了给书写在父类中的属性完成初始化的操作

能不能同时在一个子类的构造方法使用this以及super访问本类以及父类的构造方法？

​ 不能，因为this访问构造和super访问构造都要求在第一句。

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:13
 *  宠物类父类
 *  父类中书写共有的属性和方法
 */
public class Pet {
    protected String name;
    protected int health;
    protected int love;
    public String getName() {
        return name;
    }

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

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }

    public void print(){
        System.out.println("宠物的名字是：" + name);
        System.out.println("宠物的健康值是：" + health);
        System.out.println("宠物的亲密值是：" + love);
    }

    public Pet(){
        System.out.println("Pet类无参构造方法执行了");
    }

    public Pet(String name,int health,int love){
        this.name = name;
        this.health = health;
        this.love = love;
        System.out.println("Pet类全参构造方法执行了");
    }

}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 15:19
 *  猫咪类
 *      属性：毛发颜色
 */
public class Cat extends Pet {
    private String furColor;

    public String getFurColor() {
        return furColor;
    }

    public void setFurColor(String furColor) {
        this.furColor = furColor;
    }
    public Cat(){
        System.out.println("Cat类无参构造方法");
    }

    public Cat(String name, int health, int love, String furColor){
        super(name,health,love);
        this.furColor = furColor;
        System.out.println("Cat类全参构造方法执行了");

    }


    public void printCat(){
        System.out.println("猫咪的毛发颜色是：" + furColor);
        print();
    }

}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:07
 *  狗狗类
 *      属性：品种
 *      行为：打印狗狗信息
 *
 */
public class Dog extends Pet {
    private String strain;
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    public Dog(){
        System.out.println("Dog类无参构造方法执行了");
    }

    public Dog(String name,int health,int love,String strain){
        super(name, health, love);
        this.strain = strain;
        System.out.println("Dog类全参构造方法执行了");
    }

    /**
     *  用于打印狗狗信息
     */
    public void printDog(){
        this.print(); // super.print()   print()
        System.out.println("狗狗的品种是：" + strain);
    }


}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 14:10
 *  企鹅类
 *      属性：性别
 *      行为：打印企鹅信息
 *
 *  alt + insert 生成封装的方法
 */
public class Penguin extends Pet {
    private String sex;
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Penguin(){
        System.out.println("Penguin类无参构造方法执行了");
    }

    public Penguin(String name,int health,int love,String sex){
        super(name, health, love);
        this.sex = sex;
        System.out.println("Penguin类全参构造方法");
    }

    public void printPenguin(){
        System.out.println("企鹅的性别是：" + sex);
        super.print();
    }

}

/**
 * @author WHD
 * @description TODO
 * @date 2024/1/7 15:44
 *  父子类之间的构造方法
 *
 *  子类的每一个构造方法，默认访问父类的无参构造方法，除非显式的访问父类有参构造方法
 *  总结：子类的任何一个构造方法都必须访问父类的无参构造 或者 有参构造
 *
 *  为什么子类的构造方法都要访问父类的构造方法？
 *  调用父类的构造方法是为了给书写在父类中的属性完成初始化的操作
 *
 */
public class TestSubConstructors {
    public static void main(String[] args) {
        Dog dog = new Dog();

        System.out.println("*****************************");

        Cat cat = new Cat();

        System.out.println("*****************************");

        Penguin penguin = new Penguin();

        System.out.println("------------------------------------------------------");

        Dog dog1 = new Dog("大黄", 100, 100, "哈士奇");

        System.out.println("------------------------------------------------------");

        Cat cat1 = new Cat("小花", 100, 100, "红色");

        System.out.println("------------------------------------------------------");

        Penguin penguin1 = new Penguin("大白", 100, 100, "雌性");


    }
}