面向对象

面向对象（OOP）

对于描述复杂的，为了从整体上合理分析，需要面向对象。框架

对于微观操作，需要面向过程。流程

面向对象的本质

以类的方式组织代码，以对象的形式封装数据。

三大特性

• 封装（将数据包装起来）

• 继承（子类继承父类）

• 多态（同一事物的不同状态）

值传递

package com.oop.demo01;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//1

        Demo04.change(a);
        System.out.println(a);//1
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

应用传递

package com.oop.demo01;

//应用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Demo05.change(person);
        System.out.println(person.name);
    }

    public static void change(Person person){
        person.name = "无双";
    }
}

//定义一个类，有一个属性：name
class Person{
    String name;//null
}

构造器

构造器：
    1.和类名相同
    2.没有返回值
作用：
    1.new 本质在调用构造方法
    2.初始化对象的值
注意点：
    1.定义了有参构造，如果要用无参构造，显示定义一个无参构造
    
alt + insert

this.* = (当前类传过的值)

package com.oop.demo02;

//java ---> class
public class Person {
    //一个类即使什么都不写，会存在一个方法
    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //1.使用new关键字，必须要有构造器
    //2.用来初始化值
    //alt + insert -->  Select none
    public Person() {
    }

    //有参构造:一旦定义有参构造，无参就必须显示定义
    //alt + insert  生成构造器
    public Person(String name) {
        this.name = name;
    }

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

/*
    public static void main(String[] args) {

        //实例化了一个对象
        Person person = new Person("wushuang",22);
        System.out.println(person.name);//wushuang
    }
 */

总结

/*
1.类与对象
    类是一个模板，对象是一个具体的实例
2.方法
    定义、调用！
3.对应的应用
    引用类型：基本类型（8）
    对象是通过引用来操作的：栈--->堆（地址）
4.属性：字段、成员变量
    默认初始化：
        数字：0   0.0
        char: u0000
        boolean: false
        引用： null
    修饰符   属性类型 属性名 = 属性值！
5.对象的创建和使用
    - 必须使用new关键字创造对象，需要构造器   Person wushuang = new Person();
    - 对象的属性    wushuang.name;
    - 对象的方法    wushuang.sleep();
6.类：
    静态的属性
    动态的行为
7.封装、继承、多态  
  
 */

封装

高内聚，低耦合

属性私有：get/set

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

继承

一个儿子只能有一个爸爸

Object类：老父亲

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

this：
 代表的对象不同：
     this：本身调用这个对象
     super：代表父类对象的应用
 前提：
     this：无继承也可以使用
     super：只能在继承条件下使用
 构造方法：
     this：本类的构造
     super：父类的构造

方法的重写

重写：需要有继承关系，子类继承父类的方法
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大：  public > protected > default > private
    4.抛出异常：范围可以被缩小，不能被扩大

重写：子类方法与父类方法一致，方法体不同！

为什么需要重写？

• 父类的功能，子类不一定需要，或者不满足！
• Alt +Insert :override;

多态

/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系  类型转换异常！
3.存在的条件：继承关系；方法需要重写；父类引用指向子类对象！

    1.static  属于类，不属于实例
    2.final  常量；
    3.private  私有
 */

/*
1.父类引用指向子类对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型；强制转换
4.方便方法调用，减少重复的代码

 抽象：   封装；继承；多态
 */

抽象类

//abstract 抽象类：类    extends 单继承   （接口可以多继承）
public abstract class Action {
    
    //约束   有人帮我们实现
    //抽象方法，只有名字，没有方法
    public abstract void doSomething();
    
    //1.不能new出来，只能靠子类实现它：约束
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
    
    //思考题   存在构造器吗
            //存在的意义    提高开发效率
    
}

接口

普通类：只有具体实现

抽象类：具体实现和规范都有

接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程

接口的本质是契约

作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.public abstract
    4.public static final
    5.接口不能被实例化，接口中没有构造方法
    6.implements可以实现多个接口
    7.必须要重写接口中的方法

内部类（选修）

奇葩代码