封装，继承，this和super，方法重写

封装，继承，this和super，方法重写

封装–000

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

//Alt + insert 快捷键 快速生成get/set方法
/*
封装的意义：
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节，
3.统一接口
4.提高了系统的可维护性
 */

//一个类  学生类
public class Student {
    //加private关键字  表示属性私有外部不可用
    private String name;//名字
    private int  id;//学号
    private char sex;//性别
    private byte  birthday;//生日

    //提供可以操作这些属性的 方法
    //提供一些public 的get,set方法

    //get 获得这个属性/数据
    public String getName(){
        return this.name;
    }
    public int getId(){
        return id;
    }
    
    //set 给这个数据设置值
    public String setName(String name){
       return this.name = name;
    }
    public int setId(int id){
        return this.id = id;
    }
}

public class Application {
    public static void main(String[] args) {

        Student A1 = new Student();

        A1.setName("喜洋洋");
        System.out.println("姓名:"+ A1.getName());

        A1.setId(123456);
        System.out.println("学号:"+ A1.getId());
    }
}

继承

子类继承父类，就会拥有父类的全部方法

extends 关键字 继承/扩展的意思

在Java中所有的类都默认直接或者间接继承Objech类

//修饰符：public 公共的
//private  私有的
//default  默认的
//protected  受保护的

集成度本质是对某一批类的抽象，从而实现对现实世界更好的建模

Java中只有单继承没有多继承。意思是：一个父类可以有很多个子类，但是子类一定只能继承一个父类。

package oop.Dem03;
//Person  人  父类
public class Person {
        //在Java中所有的类都默认直接或者间接继承Objech类
        //修饰符：public 公共的
        //private  私有的
        //default  默认的
        //protected  受保护的
    private int moey = 100000;

    public void A1(){
        System.out.println("狼来了");
    }

    public int getMoey(){
        return moey;
    }
    public int setMoey(){
        return this.moey = moey;
    }
}


/**
 * package oop.Dem03;
 * //Student 学生 is  人  子类
 * //子类继承父类，就会拥有父类的全部方法
 * //extends 关键字 继承/扩展的意思
 * public class Student extends Person{
 * }
 */
 
 

/**
 * public class Application {
 *     public static void main(String[] args) {
 *         Student student = new Student();
 *
 *         student.A1();
 *
 *         System.out.println("骗取金钱："+student.getMoey());
 *     }
 * }
 * */

this和super

super注意点：
1.super 是调用父类的构造方法，且必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法！

VS

this注意点：
this和super代表的对象不同：
                    this：本身调用者这个对象。就是谁调用了他 那就是谁
                    super：代表父类对象的引用
                 前提：
                    this：没有继承也可以使用
                    super：只能在继承条件下才可以使用
                 构造方法的区别：
                    this（）：默认调用的是本类的构造
                    super（）：调用的是父类的构造

父类

package oop.Dem03;
//Person  人  父类
public class Person {
    //在Java中所有的类都默认直接或者间接继承Objech类
    //修饰符：public 公共的
    //private  私有的
    //default  默认的
    //protected  受保护的
    public Person() {
        System.out.println("Person的无参执行了");
    }

    protected String name = "大大怪";

    //私有的东西无法被继承 修饰符不能用private
    public void print(){
        System.out.println("爱吃羊肉串");
    }
}

子类

package oop.Dem03;
//Student 学生 is  人  子类
//子类继承父类，就会拥有父类的全部方法
//extends 关键字 继承/扩展的意思
public class Student extends Person{

    public Student() {
        //先执行父类是因为存在一个隐藏代码：默认调用了父类的无参构造
        //调用父类的构造器 必须要在子类的第一行
        System.out.println("Student的无参执行了");
    }
    
    private String name = "小小怪";

    public void print(){
        System.out.println("牛肉串更好吃");
    }
    public void test0(){
        print();//牛肉串更好吃
        this.print();//牛肉串更好吃
        super.print();//爱吃羊肉串
    }

    public void test(String name){
        System.out.println(name);//开心超人

        System.out.println(this.name);//小小怪

        System.out.println(super.name);//大大怪
    }
}

启动类

package oop;

import oop.Dem03.Student;
import oop.Dem03.Person;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        student.test("开心超人");
        student.test0();
    }
}

方法重写

重写：前提是必须要有继承关系，而且是子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：public(公共的) > protected（受保护的) > Default(默认的) > private(私有的)
4.抛出的异常：范围，可以被缩小但不能扩大：
重写，子类的方法和父类必须要一致：方法体不同

为什么需要重写？
             1.父类的功能子类不一定需要或者不一定满足
             2.快捷键：Alt + lns 选中 Override 就是重写的意思**

B类

//重写--都是方法的重写和属性无关
public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

A类

//A通过extends关键字 继承了B
public class A extends B{

    //Override 重写
    @Override//这个是注解：有功能的注释
    //重写的修饰符 只能是public 公共的  不能是私有的
    public void test() {
        System.out.println("A=>test");
    }
}

启动类

public class Application {
    //静态方法和非静态方法区别很大
    //静态方法：方法的调用之和左边定义的数据类型有关
    //非静态：才是重写
    public static void main(String[] args) {
        //方法的调用之和左边定义的数据类型有关
        A a = new A ();
        a.test();

        //静态方法下  父类的引用指向了子类
        B b = new A();//非静态下  子类重写了父类的方法 所以输出的还是子类
        b.test();
    }
}