今天是周二，没有什么很特别的事情。这篇博客是周三早上在公司写的，昨天晚上不知道为啥有点困，不过周三早起也很困。。是不是应该早点睡觉？从12点半睡到8点半还不够吗，那就再早点吧。嘿嘿，周三早上去公司的时候碰到了隔壁楼的一个小姐姐，虽然不是特别好看但是长得很可爱，比较年轻，看起来好像学生。好怀念在学校的时候，女生都那么单纯可爱。扯远了扯远了，是时候学习了。哎，呆的还是好尴尬，难受哦，我太弟弟了。

public class ClassTest {
    private static String word = "说了句话！";

    class Cat {
        public void say() {
            System.out.println("喵喵~~");
        }

        public void saySth() {
            System.out.println("喵喵~~" + word);
        }

    }

    public static void main(String[] args) {
        ClassTest classTest = new ClassTest();

        /**
         * 内部类，面向对象程序设计中，可以在一个类的内部定义另一个类，
         * 静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。
         * 内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。
         *
         * 在调用的时候内部类要通过外面这层类进行调用才行
         **/
        ClassTest.Cat cat = classTest.new Cat();
        cat.saySth();

        ClassTest.Cat cat1 = classTest.new Cat();
        cat1.say();
        /**
         * 匿名类
         * 匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们
         * 匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，
         * 而不是创建几个不同匿名类的一个实例
         * 匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法
         * 不要在匿名内部类编写其他的方法，是不可见的。
         * 形式为：new <类或接口> <类的主体>
         * 最后的say是直接调用匿名类定义的say方法
         */
        new Object(){
            void say(){
                System.out.println("匿名类输出");
            }
        }.say();

        //匿名内部类重写Dog类的say()方法,匿名类直接new的话需要类之前已经声名过
        new Dog(){
            void say(){
                System.out.println("汪汪汪");
            }
        }.say();

        test();

    }
    public static void test(){
        // 方法中的匿名内部类
        new Object()
        {
            void say()
            {
                System.out.println("test---say");
            }
        }.say();
        // 方法中的内部类,只是这个内部类只能在内部调用但是不能在外层的类中进行调用
        class Person{
            public void say(){
                System.out.println("Person say something!");
                class PersonSon{
                    public void say() {
                        System.out.println("i am her son");
                    }
                }
                PersonSon personSon = new PersonSon();
                personSon.say();
        }
    }
        Person person = new Person();
        person.say();

    }
}

/**
 * 文件类Dog，很普通的文件类
 */
class Dog {
    void say()
    {
        System.out.println("汪汪~~");
    }
}

接口的默认方法
假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。
但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法
通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

构造器与构造方法
我总是要把构造器和方法混淆，后来发现，方法实际上是需要用于执行java代码的，而构造器，是一个类的实例
类的实例，我们需要用类来创建对象，进而访问其属性，因为实例是需要被用来调用的，但是调用的话，我们不得不去考虑一个问题，就是对象，最终是被存储在内存里面的，而存储的时候，我们的内存不得不需要给他再另外开辟新的内存空间，那么，java是如何给这种我们所需要的类来开辟内存空间的呢？这就涉及到了java的内存机制，就是说，我们必须要给这个类制作一个构造器，而且这个构造器的名称必须和这个类的名称是一致的，这样，我们的java编译器才能识别这个类，进而给这个类在内存中开辟内存空间，也就是我们所说的，我们手动，人为的给他进行“初始化”