面向对象

以建立模型体现出来的抽象思维过程和面向对象的方法，是一种编程思维，也是一种思考问题的方式。面向对象是相对面向过程而言，面向过程强调的是功能、行为，面向对象是将功能封装进对象，强调具备了功能的对象，是人为抽象的一种编程模型。

面向对象的特点：封装、继承、多态

如何建立面向对象的思维呢？
1、先整体，再局部
2、先抽象，再具体
3、能做什么，再怎么做

变量

1、成员变量

• 静态变量（或类变量）
  在类中定义，关键字 static修饰，随着类的存在而存在
• 实例变量（或者对象变量）
  类中定义的普通变量，实例化对象时产生，通过对象来调用

2、局部变量
定义在方法中的变量，随着方法的调用而产生，方法调用结束时销毁

方法

1、构造方法
与类名相同的方法，是一种特殊的方法，主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。没有返回值,也不能用void修饰。

2、抽象方法
使用abstract关键字修饰的方法，存在于抽象类或接口中

3、静态方法
使用关键字static修饰的方法，程序运行时创建，结束时销毁

4、普通方法
定义在类中无特殊修饰符的方法，实例化对象时分配空间

类

类是一个模板，它描述一类对象的行为和状态，类中包含成员变量和成员方法

内部类
可以将一个类的定义放在另一个类的内部定义，内部类能够解决多继承问题。包括：成员内部类、局部内部类、匿名内部类、静态内部类

内部类的特性

  1、内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。2、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。3、创建内部类对象的时刻并不依赖于外围类对象的创建。4、内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。5、内部类提供了更好的封装，除了该外围类，其他类都不能访问。

成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

注意事项：第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

建议：推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时

    public InnerClass getInnerClass(){return new InnerClass();}

局部内部类

嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效

定义在方法中

public class Parcel5 {public Destionation destionation(String str){class PDestionation implements Destionation{private String label;private PDestionation(String whereTo){label = whereTo;}public String readLabel(){return label;}}return new PDestionation(str);}public static void main(String[] args) {Parcel5 parcel5 = new Parcel5();Destionation d = parcel5.destionation("chenssy");}
}

定义在作用域内

public class Parcel6 {private void internalTracking(boolean b){if(b){class TrackingSlip{private String id;TrackingSlip(String s) {id = s;}String getSlip(){return id;}}TrackingSlip ts = new TrackingSlip("chenssy");String string = ts.getSlip();}}public void track(){internalTracking(true);}public static void main(String[] args) {Parcel6 parcel6 = new Parcel6();parcel6.track();}
}

匿名内部类

  1、 匿名内部类是没有访问修饰符的。2、 new 匿名内部类，这个类首先是要存在的。如果我们将那个InnerClass接口注释掉，就会出现编译出错。3、 注意getInnerClass()方法的形参，第一个形参是用final修饰的，而第二个却没有。同时我们也发现第二个形参在匿名内部类中没有使用过，所以当所在方法的形参需要被匿名内部类使用，那么这个形参就必须为final。4、 匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。

public class OuterClass {public InnerClass getInnerClass(final int num,String str2){return new InnerClass(){int number = num + 3;public int getNumber(){return number;}};        /* 注意：分号不能省 */}public static void main(String[] args) {OuterClass out = new OuterClass();InnerClass inner = out.getInnerClass(2, "chenssy");System.out.println(inner.getNumber());}
}interface InnerClass {int getNumber();
}

静态内部类
使用static修饰的内部类我们称之为静态内部类，不过我们更喜欢称之为嵌套内部类。静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：

  1、 它的创建是不需要依赖于外围类的。2、 它不能使用任何外围类的非static成员变量和方法。

抽象类

抽象类必须使用abstract修饰符来修饰。抽象方法也必须使用abstract修饰符来修饰，不能有方法体。抽象类不一定包含抽象方法，但包含抽象方法的类一定是抽象类。抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。

接口

抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

抽象类与接口的差异

类与类之间的关系

1、继承（或泛化）
子类继承父类，子接口继承父接口

2、实现
类实现接口

3、依赖
在A类中，使用B类作为方法的返回值类型，或者方法参数类型，或局部变量类型，称A类依赖B类

4、关联
在A类中使用B类定义了成员变量，称A类关联B类

5、聚合
聚合是关联的一种，A类由若干B类组成，但A类不能决定B类的生命周期，称A类为聚合类

6、组合
组合也是关联的一种，A类由若干B类组成，并且A类能决定B类的生命周期，称A类为组合类

装箱拆箱

装箱就是自动将基本数据类型转换为包装器类型；
拆箱就是自动将包装器类型转换为基本数据类型。

参考文章
1、https://www.cnblogs.com/zsql/p/11115244.html
2、https://blog.csdn.net/weixin_42543911/article/details/80806259
3、https://www.cnblogs.com/chenssy/p/3388487.html
4、https://blog.csdn.net/weixin_44547508/article/details/90181964
5、https://blog.csdn.net/u_ranfa/article/details/89645757
6、https://www.cnblogs.com/wang-yaz/p/8516151.html