Day10.面向对象编程OOP（2）

封装

• 该露的露，该藏的藏

  高内聚，低耦合：

  • 高内聚：类的内部数据操作细节自己完成，不允许外部干涉

  • 低耦合：仅暴露少量的方法给外部使用

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提高系统的可维护性

package com.dongfang.oop.Demo04;

//类
public class Demo01 {
    //属性私有
    private String name;//名字
    private int id;//学号
    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;
    }

    //Alt+insert
    //Getter和Setter自动生成
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120 || age<0){
            System.out.println("数据不合法");
        }else {
            this.age = age;
        }
    }
}

package com.dongfang.oop.Demo04;

import com.dongfang.oop.Demo04.Demo01;

public class Demo02 {
    public static void main(String[] args) {
        Demo01 student1 = new Demo01();

        student1.setName("东方语虑");
        System.out.println(student1.getName());

        student1.setAge(999);
        System.out.println(student1.getAge());
    }
}

继承

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

extends的意思是 扩展 ，子类是父类的扩展

JAVA中类只有单继承，没有多继承（一个子类只能有一个父类；一个父类可以有多个子类）

• 继承是类和类之间的一种关系（继承、依赖、组合、聚合）
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extands来表示
• 子类和父类之间，从意义上讲应该具有"is a"的关系

父类

package com.dongfang.oop.Demo05;

//在Java中，所有的类，都默认直接或者间接继承Object
//父类
public class Person {

    //public能被子类继承
    //private不能被子类继承
    private int money = 100000000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}

子类

package com.dongfang.oop.Demo05;

//Student is 人     派生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //Ctrl+H  结构图

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "yulv";

    public void print(){
        System.out.println("Student");
    }

    public void test1(String name){
        print();//此类中的对象
        this.print();//此类中的对象
        super.print();//父类中的对象
    }

    public void test(String name){
        System.out.println(name);//语虑
        System.out.println(this.name);//yulv
        System.out.println(super.name);//dongfang
    }
}

package com.dongfang.oop.Demo05;

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

        Student student = new Student();
        student.test("语虑");
    }
}

super

super注意点：

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

VS this：

• 代表的对象不同
  • this：本身调用者这个对象
  • super：代表父类对象的应用
• 前提
  • this：没有继承也可以使用
  • super：只能在继承条件下才可以使用
• 构造方法
  • this( );本类的构造
  • super( );父类的构造

方法重写

重写需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大：public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException--->Exception(大)

重写，子类的方法和父类必须要一直；方法体不同

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

Alt+Insert/Ctrl+O；override

package com.dongfang.oop.Demo05;

//重写都是方法的重写，和属性无关
public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

package com.dongfang.oop.Demo05;

//继承
public class A extends B{

    //Override  重写  Ctrl+O
    @Override//注解：有功能的注释
    public void test() {
        super.test();
    }
}

package com.dongfang.oop.Demo05;

import com.dongfang.oop.Demo05.A;
import com.dongfang.oop.Demo05.B;

public class Application {

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

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();
    }
}