一些基础概念

面向对象与面向过程

Java是一门面向对象编程的语言。面向对象相对于面向过程而言。

面向过程-步骤化

面向过程就是分析出实现需求所需要的步骤，通过函数一步一步实现这些步骤，接着依次调用即可。
大概就是我要干嘛就直接去干嘛
比如，我饿了要吃饭，我一个人去买菜，做饭，吃饭，刷碗，一步一步来

面向对象-行为化

面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成对象，创建了对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为。
大概就是我要干嘛，先分析这件事大概需要那些人的功能，就去找相应的人去干。
比如，我又饿了想吃饭，我先找个超市快递小哥，对象（这个是真的对象）/妈妈，洗碗机/保洁阿姨。快递小哥根据我的要求买来我要的菜，对象把买来的菜做成饭，我张开嘴对象把饭喂到嘴里，吃完后，请来的保洁阿姨把碗洗干净。（我简直是个好吃懒做的畜牲啊）

两者优缺点

面向过程优点：
性能上它是优于面向对象的，因为类在调用的时候需要实例化，开销过大。
缺点：
不易维护、复用、
扩展用途：
单片机、嵌入式开发、Linux/Unix等对性能要求较高的地方
面向对象优点：
易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点：
性能比面向过程低低耦合，简单的理解就是说，模块与模块之间尽可能的独立，两者之间的关系尽可能简单，尽量使其独立的完成成一些子功能，这避免了牵一发而动全身的问题。

类

类是一个模板，它描述一类对象的行为和状态。
好吃懒做的我们由于不停的创建对象，最后对象实在太多了，我们有必要对它进行一些共同性质的描述，这样我们在下一次找对象的时候就有了一个可供参考的模板了。

抽象类

对象都是通过类来描述的，却并不是所有的类都是用来描绘对象的。
比如，有个类描述，有眼睛有鼻子有嘴巴，会睡觉会吃饭，你或许以为这是一个描述人的类，于是你new了一个出来，它却咬了你一口，因为它也可以描述一条狗（开玩笑，抽象类是不能实例化的）。它并不是一个具体的类，它是将很多类的一些共性抽取出去创建的一个抽象描述的类。
抽象类可以被具体的类继承，由于共通的属性已经抽取出来，继承的类不需要再为这些属性重新定义，并且可以继承抽象类的方法，根据自身具体情况进行重写。
那抽象类存在的意义是什么呢？
我觉得吧，便于快速认识类的作用，一个类如果继承于一个哺乳动物类，那么通常情况下，你不应该寄希望于它可以进行光合作用，另外，将共同的属性抽取出来，继承的类不需要再进行重复定义（如果你愿意，也可以），省时高效。结合多态特性，实现各种功能。

内部类

成员内部类

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

public class ClassStudy {
    private String name = "外部名字";
    private static String hair = "外部静态头发";
    private static String foot = "外部静态脚";
    private void hello(){
        System.out.println("外部sayHello");
    }
    private void onlyWaiBuHello(){
        System.out.println("只有外部sayHello");
    }
    private class ChengYuanNeiBuClass{
        private String name = "内部名字";
        private int age = 20;
        private String hair = "内部头发";
        private void hello(){
            System.out.println("内部sayHello");
        }
        private void shuchu(){
            hello();
            onlyWaiBuHello();
            System.out.println(name);
            System.out.println(hair);
            System.out.println(foot);
            System.out.println(ClassStudy.this.name);
            ClassStudy.this.hello();
            System.out.println(age);
        }
    }
    public static void main(String[]args){
        new ClassStudy().new ChengYuanNeiBuClass().shuchu();
    }
}

输出结果:
内部sayHello
只有外部sayHello
内部名字
内部头发
外部静态脚
外部名字
外部sayHello
20

小结：
1、成员内部类可以无条件访问外部类上的成员变量和成员方法（包括private成员和static成员）
2、当内部类拥有和外部类同名的成员变量和成员方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

内部类可以拥有 private 访问权限、protected 访问权限、public 访问权限及包访问权限。比如上面的例子，如果成员内部类 Inner 用 private 修饰，则只能在外部类的内部访问，如果用 public 修饰，则任何地方都能访问；如果用 protected 修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被 public 和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。(这一段是copy的，无用且枯燥）

局部内部类

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

class FuLei{
    public String name = "父类名字";
    public static String hair = "父类静态头发";


    public String getName() {
        return name;
    }

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

    public static String getHair() {
        return hair;
    }

    public static void setHair(String hair) {
        FuLei.hair = hair;
    }

    public void hello(){
        System.out.println("父类sayHello");
    }
    public void onlyFuLeiHello(){
        System.out.println("只有父类sayHello");
    }
}


public class JuBuNeibuClassStudy {
    private String name = "外部名字";
    private static String hair = "外部静态头发";
    private static String foot = "外部静态脚";

    public String getName() {
        return name;
    }

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

    public static String getHair() {
        return hair;
    }

    public static void setHair(String hair) {
        JuBuNeibuClassStudy.hair = hair;
    }

    public static String getFoot() {
        return foot;
    }

    public static void setFoot(String foot) {
        JuBuNeibuClassStudy.foot = foot;
    }

    public FuLei getJuBuNeiBuClass(){
        class JuBuNeiBuClass extends FuLei{
            private String name = "内部名字";
            private int age = 20;
            private String hair = "内部头发";
            public void hello(){
                System.out.println("内部sayHello");
            }
        }
        return  new JuBuNeiBuClass();
    }
    private void onlyWaiBuHello(){
        System.out.println("只有外部sayHello");
    }

    public static void main(String[]args){
        JuBuNeibuClassStudy juBuNeibuClassStudy = new JuBuNeibuClassStudy();
        FuLei fuLei = juBuNeibuClassStudy.getJuBuNeiBuClass();
        System.out.println(fuLei.name);
        System.out.println(fuLei.hair);
        System.out.println(fuLei.getName());
        fuLei.hello();
        fuLei.onlyFuLeiHello();
    }
}

注意: 局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

匿名内部类

暂略

静态内部类

暂略

对象

对象是类的一个实例，有状态和行为。
突然发现苦心孤诣地去描述类与对象的关系实在是意义不大，本就不是什么自然规律，只是人为的一些设定。也不会有完美的逻辑自适应，何必纠结