Java面向对象

什么是面向对象

 1. 面向过程 步骤简单清晰
 2. 面向对象 分类的思维模式 适合处理复杂的问题
 3. oop 以类的方式组织代码，以对象的组织(封装)数据
 4. 特点: 抽象
 5. 特性: 封装、继承、多台

回归方法的定义和调用

 1. 方法的定义
    1. return代表方法结束了
    2. 修饰符 返回值类型 方法名 方法体 返回值 异常抛出
    3. public void say() thorws IOException{}
 2. 方法的调用
    1. 静态方法  可以使用类直接调用
    2. 非静态方法 一定要创建实例才能调用
    3. static方法是和类一起加载的 而static的方法是在实例后才创建的  所以static方法是没办法直接在类中调用非static方法的
    4. java是值传递的  只会传值给他 所以形参修改不会修改原来的参数 引用传递的情况

类和对象

 1. 构造器 没有返回值 方法名和类的名字相同
 2. 构造器的作用， 实例化初始值
 3. new一个对象的时候本质是调用构造器
 4. 一旦定义了有参构造 就一定要显式的定义无参构造

对象的引用

 1. 对象是通过引用来操作的
 2. 栈中存有实际对象的引用，栈--->堆
 3. 类实例化为对象的时候 属性（成员变量）会初始化
 4. 对象的方法和属性都通过 实例名.方法or属性
 5. 静态的属性和动态的方法 

封装

 1. 高内聚 低耦合 类的内部数据操作细节自己完成 不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
 2. 封装大部分时间都是对属性的 并且同时给属性提供一些public的get or set 方法
 3. 封装的意义: 属性私有/get/set 安全 

继承

 1. 子类继承了父类 就会继承所有方法 extends
 2. 父类的私有属性会被隐式继承
 3. 在java中所有的类都直接或者间接继承object
 4. java中只能单继承 不能多继承

super - this

 1. super调用父类的属性和方法
 2. this调用子类的属性和方法
 3. 默认会调用子类（自己）的属性和方法
 4. 父类的private方法和属性是不能用super直接调用的
 5. 构造函数会先调用父类的构造方法( 其实调用的是super(); )
 6. 父类的构造函数(super();)必须放在子类构造器的第一行
 7. 子类的构造器this()同样只能放在第一行，但是父类和子类的构造方法只能存在一个

方法的重写

 1. 重写和重载的区别要注意
 2. 重载是自己类中的同一个方法依据传参所修改
 3. 重写是子类重写父类的方法
 4. 优先使用子类的方法
 5. 重写只能重写方法 和属性没有关系
 6. 重写跟静态方法没有关系
 7. 非静态方法才能重写 并且参数列表必须相同
 8. 方法的范围可以扩大但是不能缩小(public>protected>default>private)
 9. 抛出的一场：范围可以缩小 但是不能扩大

多态

 1. 实现动态编译
 2. 一个对象的实际类型是确定的
 3. 但是一个对象的引用类型不一定
 4. 父类的引用可以指向子类
 5. Person person = new Student();
 6. 会优先调用子类重写的方法
 7. 某个对象能执行什么方法主要看声明类的时候（左边）有哪些方法 比如上面就是只能调用Person存在的方法 不能直接调用子类自己的方法
 8. 某个类能调用的方法都是自己的和父类的
 9. 可以通过强制转换成子类然后调用子类的方法((Student) person).子类方法
 10. final/static/private是不能重写的 所以也不能多态

instanceof

 1. instanceof能判定类的亲子关系
 2. 子类可以直接转换成父类
 3. 父类转换成子类需要强制转换 主要用于使用子类的特有防范 重写方法可以直接调用子类的
 4. 子类转化成父类可能丢失一些方法

static关键字

 1. 静态的变量是类的  在内存中只有一个  
 2. 静态的方法也是类的  可以直接调用
 3. 只有跟类一起加载的方法和属性才可以直接访问
 4. 静态方法块>匿名方法块>构造方法
 5. 静态方法块是和类一起加载的 所以只运行一次 匿名和构造会每次实例化的时候调用

抽象类

 1. abstract修饰类 就是抽象类 或者抽象方法
 2. 继承了抽象类的子类一定要实现他的方法 除非子类也是抽象类 （这样就由下一层的子类实现）
 3. 抽象类并不能new 不能实例化
 4. 抽象类可以写普通方法  但是有抽象方法一定是必须是抽象类

接口

 1. 只有规范 自己无法写方法~ 约束和实现分离:面向接口编程
 2. 接口的本质是锲约
 3. interface是接口关键词
 4. 接口里面不能实现方法
 5. 接口中只能定义抽象接口(public abstract)
 6. 接口都需要要实现类(implemnets)
 7. 实现了接口的类一定要实现接口中的方法
 8. 可以多继承接口实现多继承

内部类

 1. 通过外部类来实例化内部类
 2. Outer.Inner inner = outer.new Inner();
 3. 静态内部类/局部内部类/
 4. 一个java类中可以有多个class类 但是只能有一个public类

package oop;

public class Student extends Person{

    public Student(){
    }
    public Student(String name,int age){
        super(name,age);
    }

    public String getName() {
        System.out.println("子类重写方法");
        return super.getName();
    }

    public void setName(String name) {
        super.setName(name);
    }

    public int getAge() {
        return super.getAge();
    }

    public void setAge(int age) {
        super.setAge(age);
    }

    @Override
    public void saySomething() {
        System.out.println("重写了这个syaSomething方法");
//        super.saySomething();
    }
}

package oop;

public class Person {
    private String name;
    private int age;

    //构造函数
    public Person() {

    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    //方法
    public void saySomething(){
        System.out.println("这个人说了一句话");
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package oop;

public class Demo01 {
    public static void main(String[] args) {
        Person student = new Student("zhouaicai",12);
        System.out.println(student.getName());
        student.saySomething();
        Object object = new Object();

    }

}