2020.7.21课堂笔记（封装和继承）

最新推荐文章于 2023-02-03 19:30:50 发布

超可爱慕之

最新推荐文章于 2023-02-03 19:30:50 发布

阅读量113

点赞数 2

分类专栏：笔记

本文链接：https://blog.csdn.net/m0_48758256/article/details/107499727

版权

笔记专栏收录该内容

138 篇文章 5 订阅

订阅专栏

封装：
保护属性
开一个出口以供使用
包：
访问修饰符：
public 公共的，全工程可见
protected：子类继承的时候使用；包级私有+子类
默认 default：包级私有，当前类所在的包中可见
private 私有的；只有自己可见
static关键字
修饰属性时：全类共用一个存储空间
普通属性：一个对象用一个存储空间
修饰方法时：可以通过类名.方法名()调用
普通方法可以直接调用静态方法和普通方法
静态方法不能直接调用普通方法
静态方法不能直接调用普通属性
但是普通方法可以调用普通属性和静态属性
静态代码块：
只在第一次访问该类时执行一次，且只执行一次
this指代的是本类的对象，static不是从属于对象的，静态是属于整个类的，所以不能用this
静态方法中不能使用this和super
静态方法必须被实现（接口和抽象类的时候）
抽象方法可以没有{}也叫没有实现
静态方法必须有结构体{}
静态变量必须是成员变量，把静态变量放在类中以外的地方都不行，就应该是从属类的
不能定义在任何方法和结构体里
继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，一个类只能有一个主类别
作为人我可能有多重身份，面对不同的场景的时候，我的主身份只有一个
即一个类只能有一个直接父类

继承：
关键字：extends，子类继承父类所有，
父类私有的东西也继承了，只是看不到
子类创建对象时，会先执行父类的无参构造方法，
再执行子类的构造方法，例外情况，如果通过super或者this指定调用某个构造方法
那么就不再执行父类的构造方法
变量：
局部变量：定义在方法中的变量，称之为局部变量，放在栈内存中，没有默认值，如果没有使用当前变量的话可以不赋值，如果使用的话一定要有初始值
作用域：从定义的位置开始到整个方法结束，归属于当前方法，想要在main函数中取不到这个值。关于for循环的问题，
注意：局部变量只能在当前方法中使用，其他地方无法使用
成员变量：存放在堆内存中，有默认值：int 0 String null boolean false ，归属于整个类
定义在方法外，类内的变量叫做成员变量（全局变量）
作用域：在整个类体内
基本数据类型4类8种
引用类型：包含类、接口、数组，Java中除了基本数据类型之外的都属于引用数据类型。Java中对象和数组都是通过引用对其操纵的
定义基本类型的时候是定义在stack里面，
int[] arr=new int[5];
在new的时候会有一小块空间在堆里面 arr里面保存的是地址，方便找到堆里面的某块内存空间的值

构造方法：创建对象的时候默认会调用构造方法来创建对象（在堆中开辟空间，可以完成成员变量的某些初始化操作）
构造方法的语法：
方法名称：构造方法的方法名称必须和类的名称保持一致
访问修饰符
形参：可以用户自定义添加，跟方法的普通参数一样
方法体：完成对象的初始化功能
返回值：没有返回值
//构造方法
public Teacher（String a,int b）{
}
public Teacher(){
}
每次new对象前必须调用构造方法，
注意：创建完类之后，如果没有手动调用构造方法，会有一个默认的无参的构造方法供调用。
当用户自定义了构造方法之后，默认的无参构造方法就不能够使用了，必须手动定义无参构造方法
同一个类中，可以包含多个同名的构造方法，
public void show(){
int a=10;//局部变量
String name=“zhangsan”;
}

this：
this表示当前对象的指针，
指向当前对象，表示当前对象的引用
用处：构造方法
当构造方法中的参数名称跟类的成员变量名称一样的时候可以使用this代表当前对象
ThisDemo td=new ThisDemo(“zhangsan”,12)

Cat：

package kb09;

public class Cat extends Pet{
    public Cat() {

        System.out.println("子类无参构造");
    }

    public Cat(String name, int health, int love) {
        //super(name,health,love);//super关键字指代父类对象，私有类一样除外
        this();
        //这里直接有参构造，但是没有逻辑
        System.out.println("子类有参构造");
    }

    public void show(){
        super.show();
    }
}

Dog

package kb09;

public class Dog extends Pet{
    //private私有化，保护属性不被篡改
    private String strain;
    /*private String name;
    private int health;
    private int love;
    //访问的接口
    public void setName(String name){//setter
        this.name=name;
    }
    public String getName(){//getter
        return this.name;//建议写上this
    }
    public void setHealth(int health){
        if(health<0 || health>100){
            System.out.println("健康值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health=60;
*//*            this.health=60;
            return;*//*
        }
        this.health=health;
    }

    public int getHealth(){
        return this.health;
    }

    public void setLove(int love){
        if(love<0 || love>100) {
            System.out.println("爱心值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love = 60;
        }
            this.love=love;
        }

    public int getLove(){
        return this.love;
    }*/

    public void setStrain (String strain){
        this.strain=strain;
    }
    public String getStrain(){
        return this.strain;
    }

}

Penguin:

package kb09;

public class Penguin extends Pet{ //extends关键字就叫继承
    private String sex;
    /*private String name;
    private int health;
    private int love;

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

    public void setHealth(int health){
        if(health<0 || health>100) {
            System.out.println("爱心值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health = 60;
        }
        this.health=health;
    }

    public int getHealth(){
        return this.health;
    }

    public void setLove(int love){
        if(love<0 || love>100) {
            System.out.println("爱心值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love = 60;
        }
        this.love=love;
    }

    public int getLove(){
        return this.love;
    }*/

    public void setSex(String sex){
        this.sex=sex;
    }
    public String getSex(){
        return this.sex;
    }
    public void show(){
        System.out.println("宠物的自白");
        System.out.println("我叫"+getName()+"，健康值是："+getHealth()
                +"，和主人的亲密度"+getLove()+"，我的性别是："+sex);
    }
}

Pet:

package kb09;

public class Pet {
    private String name;
    private int health;
    private  int love;
    int a;
    //除了我包以外，除非继承我才能看到
    protected  int b;

    //如果没有无参构造，继承会直接报错
    public Pet() {
        System.out.println("父类无参构造");
    }

    public Pet(String name, int health, int love) {
        System.out.println("父类有参构造");
        this.name = name;
        setHealth(health);
        setLove(love);
    }

    public String getName() {
        return name;
    }

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

    public int getHealth() {

        return health;
    }

    public void setHealth(int health) {

        if(health<0 || health>100) {
            System.out.println("健康值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            health = 60;
        }
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        if(love<0 || love>100) {
            System.out.println("爱心值的范围在0~100之间");
            System.out.println("赋的值不满足，强行赋默认值60");
            love = 60;
        }
        this.love = love;
    }

    public void show(){
        System.out.println("宠物的自白");
        System.out.println("我叫"+getName()+"，健康值是："+getHealth()
                +"，和主人的亲密度"+getLove());
    }
}

TestCat:

package kb09;

public class TestCat {
    public static void main(String[] args) {
        /*//无参构造方法也都是继承过来的，父类是object
        Cat c = new Cat();
        c.setName("加菲");
        c.setHealth(123);
        c.setLove(45);
        c.show();
        Pet p=new Pet("miaomiao",12312,123);
        c.show();*/
        //走父类的无参构造，目的，用来构建对象，创建对象的功能是从object拿过来的
        Cat cat=new Cat("miaomiao",123,123);
        cat.show();
    }
}

TestDog:

package kb09;

import java.util.Scanner;

public class TestDog {
    public static void main(String[] args) {
        /*Dog d=new Dog();
        d.setName("阿黄");
        String str=d.getName();
        System.out.println(str);
        d.setHealth(-100);
        System.out.println(d.getHealth());
        d.setLove(70);
        System.out.println(d.getLove());
        d.setStrain("柯基");
        System.out.println(d.getStrain());*/
        System.out.println("欢迎来到宠物店！");
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要领养的宠物的名字");
        String name=sc.next();
        System.out.println("请输入要领养的宠物类型(1、狗狗 2、企鹅)");
        int type=sc.nextInt();
        if(type==1){
            Dog d=new Dog();
        }else if(type==2){
            Penguin p=new Penguin();
            System.out.println("请选择企鹅的性别(1、Q仔，2、Q妹)");
            int sexInt=sc.nextInt();
            System.out.println("请输入企鹅的健康值：(1~100)");
            int health = sc.nextInt();
            p.setName(name);
            p.setHealth(health);
            p.setSex(sexInt==1?"Q仔":sexInt==2?"Q妹":null);
            p.show();
        }

    }
}