Java OOP面向对象：对象内存分析、Static关键字、抽象类、接口、成员内部类、静态内部类、局部内部类、匿名内部类

感谢：bilibli主播 —— 狂神说Java
这个博主的教学视频十分良心！超级赞！全栈Java的学习指导！
链接：https://space.bilibili.com/95256449/video
本博客是本人观看 狂神说Java 的Java课程所做的笔记，与 狂神说Java 开源教学视频搭配更佳！！

---

面向对象编程OOP

面向对象编程(Object-Oriented Programming,OOP)

本质：以类的方式组织代码，以对象的组织(封装)数据。

特点：封装性、继承性、多态性

从认识的角度：先有具体的对象，然后从这些对象中总结出共同的特点，产生类。

从代码运行角度：从类创建出一个一个具体的对象。

1、面向过程 & 面向对象

• 面向过程思想

  这是一个线性思维，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现。

  优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

  缺点：没有面向对象易维护、易复用、易扩展

• 面向对象思想

  把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

  优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统

  缺点：性能比面向过程低

对于描述复杂的事物，为了从宏观上把握、从整体上去合理分析，我们需要用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

2、类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述\定义，但并不能代表某一个具体事物
• 对象是抽象概念的具体实例

3、构造器(构造方法)详解

一类什么都不写，在编译完成之后，它也会存在一个无参构造的空方法。

构造方法的作用是实例化初始值。

• 使用new关键字，必须要有构造方法；
• 当定义了有参构造方法，还需要使用无参构造方法，那么就必须显示定义无参构造方法
• 为了避免程序，定义类的时候将无参构造都显示定义，留着备用也可

4、创建对象内存分析

5、OOP三大特点

请移步至该文章：
面向对象编程OOP的三大特点

6、Static关键字详解

静态代码块 匿名代码块 构造器

public class Demon{
    // 1 最早加载，且只执行一次
    static{
        System.out.println("静态代码块");
    }
    
    // 2 作用可以赋初始值
    {
        System.out.println("匿名代码块");
    }
    
    // 3
    public Demon(){
        System.out.println("构造方法");
    }
    
    public static void main(String[] args){
        Demon d1 = new Demon();
        System.out.println("======================");
        Demon d2 = new Demon();
    }
}

输出结果：

静态代码块

匿名代码块

构造方法

======================

匿名代码块

构造方法

通过执行顺序，可知静态代码块最先执行，它与类一同加载，并且只执行一次。

静态导入包

// 静态导入包
import static java.lang.Math.random;

public class Test{
    public static void main(String[] args){
        System.out.println( random() );
    }
}

通过静态导入包的方式，可以不用使用类来调用方法，可以直接使用该方法。比如上示例子，如不静态导入包，则必须使用Math.random()。

7、抽象类

关键字：abstract

• abstract修饰符可用来修饰方法即抽象方法，也可以修饰类即抽象类。
• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
• 抽象类是用来让子类继承的(单继承)；抽象方法是只有声明没有方法的实现，它是用来让子类实现的。
• 子类继承抽象类，就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
• 抽象类中可以写普通方法。
• 构造方法，类方法不能声明为抽象方法。
• 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

1）抽象类不能被实例化，但是有构造方法吗？ 面试

可以有，抽象类可以声明并定义构造函数。只是不能被实例化而已。

因为你不可以创建抽象类的实例，所以构造函数只能通过构造函数链调用（Java中构造函数链指的是从其他构造函数调用一个构造函数）。例如，当你创建具体的实现类。

2）如果你不能对抽象类实例化，那么构造函数的作用是什么？

它可以用来初始化抽象类内部声明的通用变量，并被各种实现使用。另外，即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super()。

3）抽象类存在的意义

就是为了增加代码的重用性，提高开发效率，有较好的可扩展性。

比如当游戏需要创建一个角色的时候，很多特征都是相同的，但是又有某些方法是独特的，所以可以继承抽象类，将抽象类中的抽象方法，进行独特化，创建出属于每个角色的特征。

8、接口

关键字：interface

public interface User{
    // 接口中定义的变量都是常量 public static final
    // public static final int AGE = 18;
    int AGE = 18;
    
    // 系统会默认给你添加 public abstract
    // public abstract void run();
    void run();
}

【作用】

• 接口通过接口的方法去约束别人的实现
• 定义一些方法，让别人去实现
• 接口不能被实例化，没有构造方法
• 类通过implements可实现多个接口
• 必须要实现接口中的所有方法

1）普通类、抽象类、接口的区别

普通类：只有具体的实现。

抽象类：具体实现和规范(抽象方法)都有。

接口：只有规范！约束和实现分离：面向接口编程

9、N种内部类

内部类就是一个类的内部再定义一个类。

分为：成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类

静态内部类

public class Outer{
    private int id = 10;
    public void out(){
        System.out.println("This is Outer");
    }
    
    public static class Inner{
        public void in(){
            System.out.println("This is Inner");
        }
    }
}

静态内部类，与外部类一同加载。所以静态内部类，不能访问外部类的非静态成员。

局部内部类

public class Outer{
    // 局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名内部类

public class Test{
    public static void main(String[] args){
        // 没有变量来接收实体化的类
        new Apple().eat();
        // 通过匿名内部类方法写的接口，就可以在主类种new一个接口来实现接口的方法
        // 返回的是结果，并不是存储它的变量
        UserService userService = new UserService(){
            @Override
            public void hello(){
                
            }
        }
    }
}

class Apple{
    public void eat(){
        System.out.println("Eatting...");
    }
}

interface UserService{
    void hello();
}

---

感谢：bilibli主播 —— 狂神说Java
这个博主的教学视频十分良心！超级赞！全栈Java的学习指导！
链接：https://space.bilibili.com/95256449/video