java面向对象04-封装，继承，多态

java三大特征

封装

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

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

属性私有 get/set

// class
public class Student {

    // 属性私有
    private String name; // name
    private int id; // student id
    private char sex; // gender
    private int age;
    // 提供一些可以操作这个属性的方法
    // public 的 get set 方法

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

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

    public int getAge() {
        return age;
    }
// 设置范围，是数据更加合乎规范
    public void setAge(int age) {
        if (age>120 || age<0) {
            this.age = 3;
        }else{
            this.age = age;
        }
    }

    // study()

    // sleep()
}

public class Application {
    public static void main(String[] args) {
				Student s1 = new Student();
        s1.setName("joe");
        s1.getName();
        System.out.println(s1.getName());

        s1.setAge(99); // 不合法，可以通过setAge进行规避
        System.out.println(s1.getAge());
    }
}

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

定义私有属性，写get，set方法，通过该接口赋值及获取数据

---

继承

对一批类的抽象 extends (类与类之间的关系)

类与类之间还有依赖、组合、聚合等关系

子类（派生类），父类（基类）

// 在java中，所有的类都默认直接或间接继承object类
// Person -- parent
public class Person {
    private int money = 1000000000;
    public void say(){
        System.out.println("say a word");
    }

    public int getMoney() {
        return money;
    }

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

package com.zepei.oop.demo09;

// student is person  child
public class Student extends Person {
}

package com.zepei.oop.demo09;

// teacher is person  child
public class Teacher extends Person{
}

package com.zepei.oop;

import com.zepei.oop.demo09.Student;
// main()
public class Application {
    public static void main(String[] args) {
				Student s1 = new Student();
        s1.say();
        System.out.println(s1.getMoney);
    }
}

java类只能单继承，即一个子类只能继承一个父类，一个父类可以被多个子类继承

super关键字

package com.zepei.oop.demo10;

public class Person {
    public Person() {
        System.out.println("person无参构造执行");
    }

    protected String name = "zepei";
    public void print(){ // 如果是private 则无法被继承
        System.out.println("person");
    }
}

// 如果在person中写有参构造，无参构造就没有了
// 在student中就无法调用父类的无参构造，子类也无法写无参构造
// 所以类中必须有无参构造
// 即如果要写有参构造，一定要把无参构造写出来

package com.zepei.oop.demo10;

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

    private String name = "pp";
    public void print(){
        System.out.println("student");
    }
    public void test1(){
        print(); // student
        this.print(); // student
        super.print(); // person
    }


    public void test(String name){
        System.out.println(name); // String name 传递的参数 pei
        System.out.println(this.name); // 指的是 pp
        System.out.println(super.name); // zepei

    }
}

package com.zepei.oop;

import com.zepei.oop.demo10.Person;
import com.zepei.oop.demo10.Student;

public class Application {
    public static void main(String[] args) {
	 			Student student = new Student();
        //student.test("pei");
        //student.test1();
    }
}

super注意点

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

super vs this

1. 代表的事物对象不同。

   this：本身调用者这个对象

   super：代表父类对象的引用

2. 前提

   this：没有继承也可以使用

   super：只能在继承条件下才能使用

3. 构造方法

   this()：本类的构造

   super()：父类的构造

方法的重写 override

// 继承
public class A extends B{

//    public static void test(){
//        System.out.println("a->test()");
//    }

    @Override // 注解：有功能的注释
    public void test() {
        // super.test(); 默认调用父类
        System.out.println("a->test()"); // 和父类的方法体不同
    }
}

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

import com.zepei.oop.demo10.A;
import com.zepei.oop.demo10.B;

public class Application {
    public static void main(String[] args) {
      	// 静态方法和非静态方法区别很大
        // 静态方法：方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test(); // a->test() class A
        // 父类的引用指向了子类
        // 非静态方法：子类重写了父类的方法
        B b = new A();
        b.test(); // b->test() class B // 如果是非静态方法，结果为a->test()
    }
}

重写总结

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

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大，但不能缩小

   Public > protected > default > private

4. 抛出的异常：范围可以被缩小，但不能扩大

   ClassNotFoundException --> Exception(大)

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

为什么需要重写？

1. 父类的功能，子类不一定需要，或者不一定满足

---

多态

// parent
public class Person {
   public void run(){
       System.out.println("run");
   }
}

// child
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

// main()
import com.zepei.oop.demo11.Student;
import com.zepei.oop.demo11.Person;
public class Application {
    public static void main(String[] args) {
        // 多态

        // 一个对象的实际类型是确定的
        // new Student();
        // new Person();

        // 可以指向的引用类型是不确定的
        // Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        // Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student(); // 父类的引用指向子类，通过父类new子类
        Object s3 = new Student();

        s2.run(); // student没有重写之前output：run；重写之后output：son
                  // 子类重写了父类的方法，执行之类的方法
        s1.run(); // op:son

        // 对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.eat(); // op:eat
        s2.eat(); // 报错：因为s2的类型是Person，Person中没有eat方法

    }
}

多态注意事项

1. 多态是方法的多态，属性没有多态

2. 父类和子类，有联系 类型转换异常，ClassCastException

3. 存在的条件：继承关系：方法需要重写，父类引用指向子类对象

   father f1 = new son();

   有的方法不能被重写：

   • static方法，属于类，不属于实例
   • final 常量
   • private 方法