JAVA面向对象-封装-继承-多态

一、封装(属性私有化：get/set)：

解释：高内聚(理解：自己的事情自己做)，低耦合(少暴露)；

关键字：private(私有化)；get(获取数据)；set(设置数据)；

优点：提高了安全性，复用性，高内聚，低耦合;

提示：get/set实现快捷键(alt + ins)

封装案例代码：

main方法：

//隐藏数据，没有办法直接获取数据
public class Index_Laugh {
    public static void main(String[] args) {
        //创建对象，通过对象去获取值
        Student_Laugh laugh = new Student_Laugh();
        //设置这个娃的属性
        laugh.setName("Laugh“");
        laugh.setSex('男');
        laugh.setAge(23);
        laugh.setID(7702);
        //输出赋值结果值
        System.out.println("这个娃姓名为：" + laugh.getName());
        System.out.println("这个娃性别为：" + laugh.getSex());
        System.out.println("这个娃年龄为：" + laugh.getAge());
        System.out.println("这个娃学号为：" + laugh.getID());
    }
}

封装的：

//面向对象之封装
//关键字： private：属性私有化;  get：获取数据;   set：设置数据(可以做一些判断,验证是否合理);
//优点：提高了安全性  复用性  高内聚  低耦合
public class Student_Laugh {
    //姓名
    private String name;
    //性别
    private char sex;
    //年龄
    private int age;
    //学号
    private int ID;

    // get/set方法
    public String getName() {
        return name;
    }

    public char getSex() {
        return sex;
    }

    public int getAge() {
        return age;
    }

    public int getID() {
        return ID;
    }

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

    public void setSex(char sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        if(age>120 || age <0){
            //内部判断，设置的学生是不是千年老妖🤣
            age = 0;
        }else {
            this.age = age;
        }
    }

    public void setID(int ID) {
        this.ID = ID;
    }
}

输出结果：

二、继承(extends)：

解释：无处不在，例如：你可以继承你父亲的家产(特殊情况除外哦🤣)；

关键字：extends；

优点：提高了类的复用性，另一个作用就是向上转型;（好维护，层级关系明确）

缺点：耦合性增加了，降低了灵活性；

理解：共性抽取，代码复用(减少重复代码)，减少冗余；

继承案例代码：

main方法：

public class Index_Laugh {
    public static void main(String[] args) {
        //创建学生类
        Student_Laugh laugh = new Student_Laugh();
        //Student_Laugh这个类里面没有say方法，但是Student_Laugh这个类继承了老师的方法所以老师的公共方法学生后会有
        laugh.say();    //我输出了老师的方法
        //通过学生类，输出老师类的东西
        System.out.println("我获取的是老师说的话：" + laugh.skills);
        System.out.println("我获取的是老师的名字：" + laugh.name);
        //在这里设置老师的金额，然后老师类里面判断
        laugh.setMoney(1000000);   //我在这里猜老师的余额
        System.out.println("我猜老师的余额是：" + laugh.getMoney());
        laugh.Super();  //我是通过super获取的父类属性
    }
}

学生类(老二)：

//老二
//老二  继承  老大
//继承是类与类的关系   分为子类与父类
//关键字：super：调用父类的构造方法 只能出现在子类的方法中/方法！super和this不能同时调用构造方法
public class Student_Laugh extends Teacher_Laugh{

    //有参
    public void Super(String Names){
        System.out.println(super.Names);
    }
    //无参
    public void Super(){
        System.out.println(super.Names);
    }

}

老师类(老大)：

//老大
//修饰符：  public：公共的大家都可以学  private：私有的不允许继承哦  protected：受保护的
//特殊提醒：如果不写修饰符 系统默认为default哦  继承的人会拿到哦；Java类中只有单继承没有多继承哦！！！
//一个子类只能继承一个父类的东西，但是一个父类可以有很多个子类
//重要提示：所有的类 都会默认继承 object 类哦(只是不显示而已);  可以按 ctrl + H 查看继承关系
public class Teacher_Laugh {
    //老师的技能是大家都可以学习的
    public String skills = "老师说好孩子都是呆瓜，坏孩子喜欢钻研！";
    //我是默认的
    String name = "Laugh";
    //老师的财产是学生没办法继承的
    private int money = 100000;
    //受保护的属性
    protected String Names = "Laugh大哥哥";

    //这个是老师的方法
    public void  say(){
        System.out.println("我是小朋友Laugh！");
    }

    //我get/set后   学生可以通过其他方式获取到信息
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        if(money>this.money || money < this.money){
            System.out.println("老师的钱你搞错了！");
        }else {
            this.money = money;
        }
    }

}

输出结果：

三、多态(instanceof：可以判断两个类是否存在父子关系)：

解释：一种形式多种反馈(大概意思)

解释：第一个new的对象大家都可以理解，第二个通过老大去new一个老二，因为老二是继承了老大的所以，成立！当然也可通过它们的祖宗new了(Object)；

输出结果：

重写：(@Override)

输出结果：

解释：当子类与父类都有一个相同的方法时(子类重写父类方法)，程序则执行子类的方法；若子类没有重写父类方法则会调用父类的；

总结：Student_laugh1：能调用的方法只有自己的和自己父类的方法；Student_Laugh2:可以指向子类但是不能调用子类独有的方法；

解释:

((Student_Laugh)Student_Laugh2).Han();

因为Han方法是老二的独有方法，然而老大要用的话就需要强制转换了；