封装，继承，多态

封装

该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

封装（数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了:属性私有，get/set

属性私有，get，set

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

public class Student {
    private String name;
    private int id;
    private char sex;
}
//----------------------
public static void main(String[] args) {    
        Student s1 = new Student();
        s1.name = "a";//报错
    }
	
//使用get和set操作

//alt+insert 在idea中一键生成get，set方法
public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }
	//----------------------
public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("a");
        System.out.println(s1.getName());//a
    }

继承

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

extands的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承

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

继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
子类和父类之间,从意义上讲应该具有"is a"的关系.

object类
super
方法重写

继承

public class Person {
    private String name = "a";
	 public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void say(){
        System.out.println("shuohua");
    }//父类中 public 修饰的东西子类可以直接继承
	 //private 修饰的东西不能直接继承，需要get和set方法
}

super

//super指向父类，this指向当前类
public class Person {
    protected int age = 18; 
	}
//--------------------------
public class Student extends Person{
    private int age =17;
    public void test(int age){
        System.out.println(age);//输入的age
        System.out.println(this.age);//student的age
        System.out.println(super.age);//父类person的age
    }

}
//----------------------------
public static void main(String[] args) {
        Student s1 = new Student();
        s1.test(15);
     //15
     //17
     //18
    }

super注意点:

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

代表的对象不同:

this:本身调用者这个对象
super:代表父类对象的应用

前提

this:没有继承也可以使用
super:只能在继承条件才可以使用

构造方法

this();本类的构造
super():父类的构造

方法重写

public class A {
    public static void  test(){
        System.out.println("A test");
    }
}
//-------------------
public class B extends A{
    public static void  test(){
        System.out.println("B test");
    }
}
//--------------------
public static void main(String[] args) {
        //静态方法：方法的调用只和左边定义的数据类型有关
        B b = new B();
        b.test();
        //父类的引用指向了子类
        A a =new B();
        a.test();
    }
//输出： B test
//     A test
//-------------------
public class A {
    public  void  test(){
        System.out.println("A test");
    }
}
//-------------------
public class B extends A{
//Override 重写(public可以重写)
    @Override
    public void test() {
        System.out.println("B test");
    }
}
//-------------------
//非静态：重写
public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        B b = new B();
        b.test();
        //父类的引用指向了子类
        A a =new B();//子类重写了父类的方法
        a.test();
//输出： B test
//     B test
//-------------------

重写:需要有继承关系，子类重写父类的方法!
1．方法名必须相同
2．参数列表列表必须相同
3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!
为什么需要重写:
父类的功能，子类不一定需要，或者不一定满足!

多态

动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：
1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象 Father f1 = new Son（）；

不能重写的：
1.static 方法属于类，不属于实例
2.final 常量
3.private 方法

注意:
多态是方法的多态，属性没有多态性。

instanceof 判断是否存在父子关系

强制转换类型
父类想用子类的方法需要转换成子类
子类转换为父类可能丢失自己本来的方法