封装，继承，多态

封装，继承，多态

---

封装

---

package Notto2;

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供操作属性的方法
    //提供get set方法
    public String getName() {
        return this.name;
    }

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

    //alt+insert快捷键生成get set方法 shift键多选


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 = age;
        else
            age=3;
        this.age=age;
    }
}

import Notto2.Student;
//封装的意义
//提高代码的安全性
//隐藏代码的实现细节
//统一接口
//提高了系统的维护性
public class Application{
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setName("jiujiu");
        System.out.println(student1.getName());
        student1.setAge(999);//不合法的数据年龄过大
        System.out.println(student1.getAge());
        
        
        
    }
}

---

继承

---

package Notto3;

public class Person {
    private int money=10_0000_0000;
    public void say(){
        System.out.println("hello");
    }

    public int getMoney() {
        return money;
    }

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

package Notto3;

public class Student extends Person{

}

package Notto3;

public class Teacher extends Person{

}

import Notto3.Person;
import Notto3.Student;
import Notto3.Teacher;
//子类继承了父类就会拥有父类的全部public方法
//在java中所有类都默认直接或者间接继承Object类
public class Application{
    public static void main(String[] args) {
        Student student1 = new Student();
        Person person1 = new Person();
        Teacher teacher1 = new Teacher();
        student1.say();
        System.out.println(student1.getMoney());
    }
}

---

package Notto3;

public class Person {
    protected String name="JiuQing";

    //私有的无法被继承

    //当定义有参构造时，默认的无参构造就无法使用，就需要自己定义
    public Person() {
        System.out.println("Person 无参执行了");
    }

    public Person(String name) {
        this.name = name;
    }

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

package Notto3;

import org.w3c.dom.ls.LSOutput;

public class Student extends Person{
    private String name="JiuYe";

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类构造器必须在子类构造器的第一行

        System.out.println("Student无参执行了");
    }

    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

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

import Notto3.Student;

public class Application{
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println("===================");
        student1.test1("玖");
        System.out.println("===================");
        student1.text2();
    }
}

super注意点：
     1.super调用父类的构造方法
     2.super必须只能出现在子类的方法或构造方法中
     3.super和this不能同时调用构造方法
     
Vs this
    调用的的对象不同
       this：本身调用者这个对象
       super：代表父类对象的应用
    前提
       this：没有继承也可以使用
       super：只有在继承下才可以使用
    父类
       this()本类构造
       super()父类构造

方法重写

---

当子类继承父类的方法时，这些方法不满足自身需求时，子类可以重写继承父类的方法

子类在调用方法时，会调用自身重写的方法

package Notto4;
//重写都是方法的重写和属性无关
public class B {
    //静态方法和非静态方法区别很大
    //静态方法是类的方法
    //非静态是对象的方法
    public static void text(){
        System.out.println("B=>text()");
    }

    //public修饰的可以重写，子类重写父类
    public void test1(){
       System.out.println("B->test1()");
   }
}

package Notto4;

public class A extends B {
    public static void test(){
        System.out.println("A=>test()");
    }
    //Overrride 重写
    @Override//注解：有功能的注释
    //重写
     public void test1() {
        System.out.println("A->test1()");
    }
}

import Notto4.A;
import Notto4.B;
public class Application{
    public static void main(String[] args) {
        A a = new A();
        a.test();//A
        //父类的引用指向了子类
        //方法的调用只和定义的类型有关
        B b=new A();
        b.text();//B
        System.out.println("==================");
        //b是A new出来的所以调用的A的非静态方法
        a.test1();
        b.test1();
    }
}

重写：需要有继承关系，子类重写父类方法
      1.方法名必须相同
      2.参数列表必须相同
      3.修饰符：范围可以扩大   public>protected>Default>private
      4.抛出异常：范围：可以被缩小但不能扩大; ClassNotFoundException --> Exception
重写，子类的方法和父类必须一致，方法体不同

为什么需要重写？
    1.父类的功能子类不一定需要，或者不一定满足！
    快捷键 alt+inset override;

运行结果如下：

---

多态

• 用法为 子类的对象赋值给父类的引用，即 A类型 变量 = new A类型的子类()
• 多态一般用于子类重写父类方法的情况，当父类.方法（重写的方法）时候，调用的其实是子类中重写的方法
• 使用多态性的时候，引用的方法必须是父类中定义过的方法

package Notto5;

public class Person {

    public String name="Father";

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

package Notto5;

public class Student extends Person{

    public String name="son";

    public Student(){
        System.out.println("I am a student");
    }

    @Override
    public void run() {
        System.out.println("son");
    }

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

import Notto5.Person;
import Notto5.Student;

public class Application{

    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用的类型不确定:父类的引用指向子类
        Student s1 = new Student();//实际类型都是Student
        //父类可以指向子类但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3= new Student();
        System.out.println("================");

        s2.run();//子类继承了父类的方法 重写之后执行子类的方法
        s1.run();
        //s2.eat(); 无法调用
        //对象能调用哪些方法，主要看左边的类型，和右边关系不大
        System.out.println("==================");
        System.out.println(s1.name);
        System.out.println(s2.name);
    }
}
/*
多态注意事项：
   1.多态是方法的多态，属性没有多态
   2.父类和子类，有联系   类型转换异常！ ClassCastException
   3.存在条件：
        继承关系
        方法重写
        父类引用指向子类对象
        Father f1=new Son();

        1.static:属于类，不属于实例
        2.final :无法重写
*/

运行结果如下：