对象三大特性

封装

该露的露，该藏的藏

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

封装(数据的隐藏)

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

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

eg : 

public class Student {
    //属性私有  用private
    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
    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 = 3;
        }else {
            this.age = age;
        }
    }
}

 

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student ();
        s1.setName ("小明");
        System.out.println (s1.getName ());
        s1.setAge (70) ;//不合法的
        System.out.println (s1.getAge());
    }
}

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

继承

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

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

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

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

继承关系的俩个类, 一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示

子类和父类之间，从意义上讲应该具有"is a"的关系

object类       super        方法重写

eg : 

//学生 is 人 ：派生类 ，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student  extends Person {
    public Student() {
        //隐藏代码：掉用了父类的无参构造
        super("name"); //调用父类的构造器，必须要在子类构造器的第一行
        System.out.println ("Student无参执行了");
    }
    //Ctrl + H
    private String name = "xiaoming";
    public void print() {
        System.out.println ("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
    public void test(String name){
        System.out.println (name);//小明
        System.out.println (this.name);//xiaoming
        System.out.println (super.name);//xiaohong
    }
}

//在Java中，所有的类大批默认直接或者间接继承object
//Person 人  ：父类
public class Person /*extends Object*/ {
    public Person(String name) {
        System.out.println ("Person无参执行了");
    }
    protected String name = "xiaohong";
    //私有的东西无法被继承 private
    public void print() {
        System.out.println ("Person");
    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student () ;
        student.test ("小明") ;
        student.test1 ();
    }
}
方法重写
eg :

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

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

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

/*
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(大)

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

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！
    Alt + Insert ; override;
*/

多态

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

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

多态存在的条件

1.有继承关系

2.子类重写父类方法

3.父类引用指向子类对象

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

instanceof    (类型转换)   引用类型

 eg : 

public class Teacher extends Person{

}

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

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

public class Application {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student ( );
        //System.out.println (X instanceof Y);能不能编译通过
        System.out.println (object instanceof Student);//true
        System.out.println (object instanceof Person);//true
        System.out.println (object instanceof Object);//true
        System.out.println (object instanceof Teacher);//false
        System.out.println (object instanceof String);//false
        System.out.println ("============");
        Person person = new Student ();
        System.out.println (person instanceof Student);//true
        System.out.println (person instanceof Person);//true
        System.out.println (person instanceof Object);//true
        System.out.println (person instanceof Teacher);//false
        //System.out.println (person instanceof String);//编译报错
        System.out.println ("============");
        Student student = new Student ();
        System.out.println (student instanceof Student);//true
        System.out.println (student instanceof Person);//true
        System.out.println (student instanceof Object);//true
        //System.out.println (student instanceof Teacher);//编译报错
        //System.out.println (student instanceof String);//编译报错
        System.out.println ("=================");
        //类型之间的转化：父  子
        //子类转换完父类，可能丢失自己的本来的一些方法！
        Person obj = new Student();
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student s4 = (Student) obj;
        student.go();
        //((student)obj).go();
        Person s5 = student;
        System.out.println ("==================");
        //一个对象的实际类型是确定的
        //new Student();
        //bew Person();
        //可以指向的引用类型就不确定了
        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student () ;
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person  s2 = new Student () ;
        Object  s3 = new Student () ;
        //对象能执行哪些方法，主要看对象左面的类型，和右边关系不大！
        ((Student) s2).eat();//子类重写了父类的方法，执行子类的方法
        s1.eat();
    }
}
/*

多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！  ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
   1.static 方法，属于类，它不属于实例
   2.final 常量；
   3.private 方法；

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转型； 强制转换
4.方便方法的调用，减少重复的代码！简介
抽象：  封装，继承，多态！ 抽象类，接口

*/