笔记：Java

​
高内聚，低耦合：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用。

一、封装：
含义：
1. 指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中；
2. 指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节。通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

一句话：私有属性（privat），使用getter/setter。通过getter获得这个数据，通过setter给这个数据设置值。快捷键：
1. 生成无参构造方法：Alt+Insert,然后选中Constructor；
2. 生成getter/setter方法：Alt+Insert,然后选中getter/setter。

public class Student {
    //姓名
    private String name;
    //手机号码
    private String number;
    //性别
    private char sex;
    //年龄
    private int age;
    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

    //get  获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }


    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0) {
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

	
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
                s1.setName("燚晗");
                s1.setAge(18);
                s1.setSex('女');
                s1.setNumber("186XXXX7052");

        Student s2 = new Student();
                s2.setName("杨焕");
                s2.setAge(23);
                s2.setSex('男');
                s2.setNumber("173XXXX2809");
        System.out.println("姓名："+
                s1.getName()+"n"+"年龄："+s1.getAge()+"n"+
                "性别：" + s1.getSex()+"n"+
                "手机号码："+s1.getNumber()+"n");
        System.out.println("姓名："+
                s2.getName()+"n"+"年龄："+s2.getAge()+"n"+
                "性别：" + s2.getSex()+"n"+
                "手机号码："+s2.getNumber());
    }
}

二、继承：
extends的意思是"扩展"。子类是父类的扩展。

Java只有单继承(这样理解：一个儿子只能有一个爸爸，一个爸爸可以拥有多个儿子)，没有多继承！实现多继承要用interface。

继承只是类与类之间的一种关系。除此之外，还有依赖、组合、聚合等。

继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上讲应该具有"is a"的关系。

子类可以继承父类的所有方法。

在子类方法中访问一个变量：
1.子类局部范围找
2.子类成员范围找
3. 父亲成员范围找
4. 如果都没有就报错（不考虑 父亲的父亲）

继承中构造方法的访问特点：
子类中所有的构造方法（无参/带参构造）默认会访问父类中无参的构造方法！原因: 1. 因为子类会继承父类的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化； 2. 每一个子类构造方法的第一条语句默认都是：super()。

this指向当前类、super指向父类，访问父类的属性

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

Super VS this：
1. 代表对象不同：
this： 调用本类的成员变量/成员方法/构造方法；
super：调用父类的成员变量/成员方法（但注意权限修饰符的影响，比如不能访问private成员）、以及调用父类的构造方法的访问（但只限构造方法中使用，且必须是第一条语句。）
2. 前提：
this：没继承也可以使用
super：只能在继承的前提条件下使用
3. 构造方法不同：
this：本类的构造
super：父类的构造

重写：需要有继承的关系，子类继承父类的方法！
* 重写都是方法的重写，和属性无关
* //A是子类，B是父类。父类B的引用指向子类A

    1.方法名必须相同、参数列表必须相同
    2.子类不可以重写父类中的私有方法(private)
    3.修饰符：子类的修饰符访问权限不可以低于父类的修饰符的访问权限(范围可以扩大：public > protect > default > private)
    4.重写可能抛出异常：范围，可以缩小，但不能扩大；ClassNotFoundException -->Exception(大)

重写，子类的方法和父类要一致：方法体不同！

为什么需要重写：父类的功能，子类不一定需要，或者不一定满足；

快捷键：Alt + Insert，然后选中overside;

方法重写 VS 方法重载（覆盖）:

public class Animals {
    private String name;
    private int age;
    public Animals() {
    }
    
    public Animals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Cat extends Animals {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    public void catchMouse(){
        System.out.println("开始抓老鼠！");
    }

}
public class Dog extends Animals {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    public void lookDoor(){
        System.out.println("狗开始看门！");
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("汤姆");
        cat.setAge(3);
        System.out.println(cat.getName()+","+cat.getAge());
        cat.catchMouse();

        Dog dog = new Dog("小黑",5);
        System.out.println(dog.getName()+","+dog.getAge());
        dog.lookDoor();
    }
}

三、多态：
即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型很多动态编译：类型：可扩展性多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常！ ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new Son();不能重写：
1. static方法，静态方法，属于类，它不属于实例；
2. final常量，常量池里的，无法修改，不能重写；
3. private方法；多态的好处和弊端：
**好处：**提高了程序的扩展性。具体体现：，定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作；
**弊端：**不能使用子类的特有功能(使用向上/下转型)。

public class Animal {

    public int age = 40;

    public void eat(){
        System.out.println("动物吃东西~");
    }

}
public class Cat extends Animal {  //多态条件一 ： 继承

    public int age = 20;
    public int weight = 10;

    @Override                       //多态条件二 ： 重写
    public void eat() {
        System.out.println("猫爱吃鱼！");
    }

    public void playGame(){
        System.out.println("猫捉迷藏！");
    }
}

public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗爱吃骨头!");
    }
}
public class AnimalOperator {

    public void useAnimal(Animal a){
        a.eat();

    }
}

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

        

        //创建动物操作类的对象，调用方法
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);

    }
}