JavaSE04 面向对象

一、什么是面向对象

• 万物皆对象。
• 对象就是一个概念，把所有的事物都称作为“对象”（没有不是对象的东西）
• 属性就是该事物的组成部分，所有可以被包含的部分都称为“属性”（没有不含属性的对象）
• 方法就是达成目标的途径，所有可行性的行为都成为方法（没有不存在方法的对象和属性，但是可以选择使用哪些方法）
• 举例：比如把人看成是一个对象，那么姓名，性别，生日等则是人这个对象的属性，吃饭，睡觉等行为就是人这个对象的方法。

二、类与对象

• 类：类是一种分类，一个类别，一个模板，它描述一类对象的行为和状态，是一组具有相同特性（属性）与行为（方法）的事物集合
• 对象：是一个个体的特征，是类的一个实例，有状态和行为
• 类是对象的抽象（模板Class），对象是类的具体

三、构造方法

构造方法：方法的重载，对属性进行初始化操作，构造方法名称与类名相同，没有返回值声明（包括 void）

（1）无参构造

public User() {
    }

（2）有参构造

public User(String username) {
        this.username = username;
    }

• 每一个类中都会有一个默认的无参构造方法
• 如果手动定义了一个有参构造，则默认的无参构造无效，还需手动再加一个无参构造。

（3）单例模式

构造方法私有化，让除了自己类能创建外其他地方都不可以创建

• 在自己的类中创建一个单实例（饱汉模式一出来就创建单实例，饥汉模式需要的时候才 创建）
• 提供一个方法获取该实例对象（饥汉模式创建时需要进行方法同步）
• 代码体现：

//饿汉式
class Single{
    private Single(){} //私有化构造函数。
private static Single s = new Single(); //创建私有并静态的本类对象。
    public static Single getInstance(){ //定义公有并静态的方法，返回该对象。
        return s;
    }
}

//懒汉式:延迟加载方式。
class Single2{
    private Single2(){}
private static Single2 s = null;
    public static Single2 getInstance(){
        if(s==null)
            s = new Single2();
        return s;
    }
}

四、对象的创建

new 对象 例如：User user new User();

• new关键字：表示向内存申请空间，也表示实例化一个对象，创建一个对象。
• 栈存放引用
• 堆存放具体的对象
  

五、封装

封装：属性私有化，提供get,set方法

• 好处：将变化隔离；便于使用；提高重用性；安全性
• 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
• 代码提现：

public class User {
    
    private String name;

    public String getName() {
        return name;
    }

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

六、继承

继承：如同生活中的子女继承父母拥有的所有财产，程序中的继承是指子类拥有父类数据结构的方法和机制，这是类之间的一种关系；继承只能是单继承。
好处：
1：提高了代码的复用性。
2：让类与类之间产生了关系，提供了另一个特征多态的前提。

• extends关键字
• 子类拥有父类的全部特性
• 继承只能是单继承

方法重写（override）：相对继承而言，子类中对父类已经存在的方法进行区别化的修改。

this:代表是本类类型的对象引用
super:代表是子类所属的父类中的内存空间引用。

代码提现：

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

public class Admin extends User{
    @Override
    public String getName() {
        return super.getName();
    }
}

七、多态

多态：父类的引用指向子类的对象 例如：Person person = new Student();

• 多态前提
  A:存在着继承或者实现关系
  B:有方法的重写
  C:父类(接口)引用指向子类(实现)对象
• 好处：多态的存在提高了程序的扩展性和后期可维护性

instanceof：作用是测试它左边的对象是否是它右边的类的实例

• 在写程序的时候，如果要进行类型转换，我们最好使用instanceof运算符来判断它左边的对象是否是它右边的类的实例，再进行强制转换

八、接口

接口：当一个类中的方法都是抽象的时候，java提供了另一种表示方式，叫接口。接口是一系列方法的声明，是一些方法特征的集合。

• 用interface关键字表示。类与接口关系用implements表示。
• 约束：只能定义方法名，而没有方法体
• 子类实现接口，必须重写其中的方法
• 只有一个方法的接口叫做函数式接口，可以使用lambda表达式简化
• 接口比抽象类更抽象
• 一个类可以实现多个接口
• 代码提现：

public interface USB {
    void read();
    void write();
}

public class YouPan implements USB {
    @Override
    public void read() {
        System.out.println("U盘正在通过USB功能读取数据");
    }

    @Override
    public void write() {
        System.out.println("U盘正在通过USB功能写入数据");
    }
}

九、内部类

内部类：将一个类定义在另一个给类里面或者方法里面，这样的类就被称为内部类。

内部类可以分为四种:成员内部类、局部内部类、匿名内部类、静态内部类

（1）成员内部类：成员内部类是最普通的内部类，它的定义为位于另一个类的内部

• 成员内部类无条件访问外部类的属性和方法
• 外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

（2）局部内部类：定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

（3）匿名内部类：应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护

• 代码提现：

public class Test {
    public static void main(String[] args) {
        driveCar(new Car(){
            @Override
            public void drive() {
                System.out.println("驾驶着BMW汽车");
            }
        });
    }
    public static void driveCar(Car car){
        car.drive();
    }
}

interface Car {
    void drive();
}

• 分析以上代码知道静态方法driveCar需要一个Car对象，我们通过实现接口创建一个匿名类对象传递过去。事实上还可以通过继承类来创建一个匿名内部类对象。
• 注意事项：匿名内部类没有构造方法。也是唯一没有构造方法的内部类。匿名内部类和局部内部类只能访问外部类的final变量。

（4）静态内部类：是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的。

• 静态内部类和成员内部类相比多了一个static修饰符
• 因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法

内部类的好处：

• 完善了Java多继承机制，由于每一个内部类都可以独立的继承接口或类，所以无论外部类是否继承或实现了某个类或接口，对于内部类没有影响。
• 方便写事件驱动程序。