面向对象的三大特性

封装：

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

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

封装的基本属性：属性私有化，然后get/set方法

 //属性私有化
    private String name;
    private int age;

    public String  getName(){
        return name;
    }
    //set是存数据 get是取数据
    public void setName(String name){
        this.name=name;
    }
    //运用快捷键 alt+insert写出get/set方法

    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 student = new Student();
        student.setName("张三");//存数据
        System.out.println(student.getName()); //取数据
        //还可以在封装的数据里面进行校验
        student.setAge(999);
        System.out.println(student.getAge());
    }

封装的作用：  1.提高程序的安全性，保护数据

                        2.隐藏代码的实现细节

                        3.统一接口

                        4.系统可维护性增强

继承

使用extends关键字

继承：子类继承父类的所有东西。

继承的本质是 对一批类的抽象，将相同的数据放在同一个类中。

Java只有单继承没有多继承，在Java所有类中都默认继承了object类，在ideal中可以使用ctrl+h快捷键查看一个类的继承与被继承

继承中有个核心的关键字super

public class Teacher extends Person{
    private String odd="chao";

    public void tes(String odd){
        System.out.println(odd);//小超
        System.out.println(this.odd);//chao
        System.out.println(super.odd);//超 调用父类的属性
    }
public class Person {
    protected String odd="超";

}


public class Application {
    public static void main(String[] args) {
         teacher.tes("小超");

}


}

super注意点

1. 只能放在第一行 并且是调用父类的构造器 可以调用有参也可以调用无参

2. super只能出现在子类的构造方法或者方法中

3. super和this不能同时出现

4. 比较this: this调用本身这个对象里面的东西  super调用父类里面的东西

5. 前提： this没有继承也可以用 super只能在继承的子类中使用

重写（override）：只在继承中出现，子类重写父类的方法

1. 方法名相同 参数列表相同 方法体不同

2. 修饰符的范围可以扩大但不能缩小 ：public>protected>defalut>private 重写的方法的修饰符要大于父类的方法的修饰符

3. 抛出的异常只能缩小不能扩到 意思就是说 重写的异常不能大于父类的异常

为什么需要重写呢：

当父类的功能不能满足子类的需求的时候

多态

多态：一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多，多态是方法的多态，属性没有多态

注意事项：

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

2. 父类和子类 首先得有联系 没有联系的话就会报 类型转换异常：ClassCastException

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1=new Son();

   有些方法不能被重写：

   1. static 方法 属于类 他不属于实例

   2. final 常量

   3. private方法；

        Student s1 = new Student();
        //person父类型 可以指向子类 但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

instanceof 类型转换

 关键字instanceof  判断一个对象是什么类型的，说明两个类是否有父子关系

类型转换是在多态中的。

1. 父类的引用指向子类的对象 Student student = new Student(); Person person=student;

2. 把子类转换为父类 是向上转型

3. 把父类转向为子类 向下转型 但是会丢失一些方法

4. 这都是为了 方便方法的调用 减少重复的代码。 简介

System.out.println(x instanceof y); 能否编译通过 就是判断x与y是否有继承关系（父子关系）

他的结果是true还是false主要是看 变量x所指向的类型是不是y的子类型 x所指向的类型和y有关系也会通过

拓展

static 修饰符

被static修饰的变量是静态变量，如果我们想要调用的话 推荐使用类名访问 类名点属性名来访问

非静态方法可以访问静态方法，静态方法是和类一起加载的

被static修饰的东西只执行一次

静态块

在Java中有几个块 分为匿名代码块 静态代码块 和构造方法

几个代码块的顺序 先走静态代码块>匿名代码块>构造方法

匿名代码块 一般是用来赋初始值的 他是和对象同时产生的

因为静态代码块是静态的所有运行一次之后就消失了

静态导入包

使用import关键字

就是一种导入包的形式调用这个类里面的方法

import static java.lang.Math.random;
import static java.lang.Math.PI;

写了这段代码之后 他就可以在下面直接使用方法了

System.out.println(Math.random());//输出[0,1)随机数
System.out.println(random());
System.out.println(PI);