类的三大属性

一，封装

该露的露，该藏的藏

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

封装（数据的隐藏）

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

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

例子：

结果无法被调用（如图变红）

正确代码：

public class Student{
    //属性私有
    private String name;   //名字
    private int id;   //学号
    private char sex;   //性别
    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    //get 获得这个数据
    public String getName(){
        return name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

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

 输出：

封装的好处:

1,提高程序的安全性，保护数据

2,隐藏代码的实现细节

3,统一接口（规范性）

4, 系统可维护性增加了

二，继承

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

extends的意思是扩展，子类是父类的扩展

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

super可和this对比，一个代表父，一个代表当前的

看下列代码和结果，体会区别：

public class Person {
    protected String name = "lalala";
}

public class Student extends Person{
    private String name = "hahaha";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

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

区分一下重写和重载

三，多态

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

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

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

多态存在的条件：

1，有继承关系

2，子类重写父类的方法

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

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

instanceof  (类型转换)  引用类型

通常先用instanceof判断两个类是否相似/有联系，再进行类型转换，示例代码如下：

public class Person {
    protected String name = "lalala";
}

public class Student extends Person{
    private String name = "hahaha";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

public class Teacher extends Person{
}

//System.out.println(X instanceof Y);  //能不能编译通过！
// X,Y是否有父子关系，有的话编译通过，没有的话报错
//true和false取决于X指向的实际类型是否是Y的子类型
//Object类是所有类的父类
public class demon{
    public static void main(String args[]){
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        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);   //编译报错！
    }
}

然后再强制转换：

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

public class Student extends Person{
    private String name = "hahaha";
    public void go(){
        System.out.println("go");
    }
}

public class demon{
    public static void main(String args[]){
          //类型之间的转化：  基本类型转化    父  子
          //高转低叫作强制转化
        Person obj = new Student();
        //obj.go()会报错
        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        //第一种方法
        Student student = (Student) obj;
        student.go();
        //第二种方法，比较好理解
        ((Student)obj).go();
    }
}

 结果：

1，父类引用指向子类的对象

2，把子类转换为父类，向上转型，会丢失子类自己的一些特有的方法

3，把父类转换为子类，向下转型      强制转换

4，方便方法的调用，减少重复的代码，简洁！