封装，继承，多态

• 封装
• 继承
• • super
  • super Vs this
  • 方法从写
• 多态
• • 多态的注意事项

• 该露的露，该藏的藏
• 高内聚，低耦合
• 封装（隐藏的数据）
  • 通常，应该禁止直接访问一个对象中的数据实际表示，而应该通过接口来访问，这称为信息隐藏
  • **记住这句话就够了：属性私有，get/set **

package Demo3;

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

        Student s1 = new Student();
        s1.setName("pofen");
        s1.setAge(9);
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
        s1.Study();
    }
}

package Demo3;

public class Student {
    //private 属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;
    //学习（）
    //睡觉（）
    //提供一个可操作性的方法
    //提供一些public 的get，set方法
    //get 获得这个数据
    public void  Study(){
        System.out.println(name+"在学习");
    }

    public String getName() {
        return name;
    }

    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;
        }
    }

}

//set 给这个数据设置值

• Alt+insert :自动生成set/get方法

pofen
9
pofen在学习

• 封装的作用
  1. 提高程序的安全性，保护数据
  2. 隐藏代码的细节
  3. 统一接口
  4. 系统可维护增加了

• 继承的本质是对某一批类的抽象，从而事项对现实世界更好的建模
• extends的意思是“扩展”。子类是父类的扩展
• JAVA中只有单继承单继承，没有多继承（一个儿子只有一个类，一个类可以有多个儿子）
• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
• 继承的关系是两个类，一个子类（派生类)，一个为父类（基类）。子类继承父类，使用extends表示
• 子类和父类之间，意义上将应该应具有“is a"关系
• object类
• super
• 方法重写

package Demo4;
public class  Student extends  Person{

}

package Demo4;
//person 人 父类
public class Person {
    //public 公共的
    //private 私有的
    public int money = 10_0000_0000;
    public void say(){
        System.out.println("说了破风真帅");

    }
}

package Demo4;

public class teacher extends Person{
    
}

package Demo4;

public class teacher extends Person{
}

• person 人 父类

• 学生 is 人 ：派生类 ，子类

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

• Ctrl+H：会打开一个继承树列表

• 在JAVA中，所有的类都默认直接或者间接继承object类

package Demo4;
public class  Student extends  Person{
private String name = "poFenx";
public void test(String name){
    System.out.println(name);//波哥
    System.out.println(this.name);//poFenx
    System.out.println(super.name)//pofen
}
}

package Demo4;
//person 人 父类
public class Person {
   protected  String name ="pofen";
    }

package Demo4;

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

Application

package Demo4;

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

Student

package Demo4;
public class  Student extends  Person{
private String name = "poFenx";
public void print(){
    System.out.println("Student");
}
//隐藏代码；调用了父类的无参构造
    //调用父类构造器，必须要在子类构造器的第一行
    //this也要在第一行
public Student(){
    super();//有参调用有参数，如果不写默认调用无参
    System.out.println("Student无参构造执行了");

}
public void test1(){
    print();//Sutdent
    this.print();//Student
    super.print();//Person
}
public void test(String name){
    System.out.println(name);//波哥
    System.out.println(this.name);//poFenx
    System.out.println(super.name);//pofen
}
}

Person

package Demo4;
//person 人 父类
public class Person {
    public Person(){
        System.out.println("Perosn无参构造执行了");

    }

   protected  String name ="pofen";
   public  void print(){
       System.out.println("Person");
   }
    }

• super小结

1. super调用父类的构造方法，必须在构造的第一个
2. super必须只能出现在之类的方法或者构造方法中
3. super和this不能同时调用构造方法，因为他们要调用的话必须都都放在第一行

• super Vs this

  代表对象不同

  this：本身调用者这个对象：谁调用就是谁

  super：代表父类对象的引用

  前提

  this ：没有继承（extends）也可以使用

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

  构造方法

  this（）本类构造

  super（） 父类构造

• 重写

  需要有继承关系，而且是子类重写父类的方法，不能重写属性

1. 方法名必须相同

2. 参数列表必须相同，否则就是重载了，而且重载是当前方法

3. 修饰符：范围可以扩大：public>protected>Default>private

4. 抛出异常：范围可以被缩小，但是不能扩大classNotfoundException–>Exception(大)

   ---

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

为什么需要重写：

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

   Alt+Insert+override :重写

   Application

package Demo4;

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

A

package Demo4;
//继承
public class A extends B {
     //Overide 重写
    @Override//注解，有功能的注解
    public void test() {
     System.out.println("A=>test()");
    }
}

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

B

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

• 动态编译：类型：可扩展型

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

• 一个对象实际类型是确定的，但可以指向对象的引用类型有很多（父类，关系的类）

• 多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向对象

• 注意：多态是方法的多态，属性没有多态

• instanceof ：类型转换 引用类型的转换

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

2. 父类和子类，有联系，类型转换异常，不能瞎转换 ClassCastException！:类型转换异常（看到这个说明父子类之间出现了一些问题

3. 存在的条件： 继承关系，方法的重写

4. 父类的引用指向指向子类对象 Father f1 = new Son();

   ---

   有序方法不能被重写

   1. static 方法 属于类 ，他不属于实例
   2. final 常量
   3. private 方法：

   Application

   package Demo5;
   
   public class Application {
       public static void main(String[] args) {
   
       // new Student();
       // new Person();
       //一个对象的实际类型是确定的 :比如说都是Student
       //可以指向的引用类型是不确定的  ：Student s1,Person s2,Object s3
       
   Student s1 = new Student();
    //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person  s2 = new Student();//父类的引用指向子类
           Object  s3= new Student();
           s2.run();//子类重写了父类的方法,执行子类的方法
           s1.run();//看类型，哪一个类型就执行谁的，两个类型都有的时候就执行子类的了
           ((Student) s2).eat();//类型强制转换
           //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
           
       }
       }
   
   

Student

package Demo5;

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

Person

package Demo5;

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