面向对象

//java基础视频教程第05-01-面向对象(概述)
/*
    本节课主要面向对象的概述
    面向对象是相对面向过程而言的，它是基于面向过程
    面向对象是将功能封装成对象，通过对象去调用内部的功能
    面向对象有三个特征:封装，继承，多态
*/

//java继承视频教程第05-01-面向对象(举例)
/*
    手机是一个对象，人是一个对象，电脑是一个对象，女朋友也是一个对象，总而言之一切皆对象，万物皆对象
*/

//java基础视频教程第05天-03-面向对象(类与对象的关系)
/*
    本节课主要讲解了类与对象的关系
    类就是对某一类事物的描述，描述包括这类事物的功能和属性,这些功能和属性就是类的成员变量
    对象就是这类事物的实实在在的个体，在java中的表现就是在堆内存中new一个实体
*/

//java基础视频教程第05天-04-面向对象(成员变量和局部变量)
/*
    本节课主要讲解了成员变量和局部变量的区别
    1.作用范围上的区别
    成员变量作用于整个类中
    局部变量作用于函数中或者语句中
    2.在内存中的位置
    成员变量在堆内存中，因为对象的存在而存在
    局部变量存在与栈内存中
*

//java基础视频教程第05天-05-面向对象(匿名对象的应用)
/*
    本节课主要讲解了匿名对象的两种用法
    1.当对象的方法只调用一次时，可以用匿名对象来调用，这样比较简化
    2.把匿名对象作为参数传递
    注意：匿名对象更改属性没有意思，因为匿名对象没有指向
*/
class Car
{
    //车的颜色
    String color="red";
    //车的轮胎数
    int num = 4;
    //车的运行方法
    public void run()
    {
        System.out.println(color+"---"+num);
    }
    
}
class CarDemo
{
    public static void main(String[] args) 
    {
        new Car().color="blue";        //匿名对象更改属性没有意义
        new Car().num = 6;            //当你new一个对象之后又是一个新的对象了，前面new的那个对象已经成为了垃圾了。
        new Car().run();        //当然匿名对象可以直接调用对象方法。
        change(new Car());            //匿名对象可以直接作为参数传递，
    }
    public static void change(Car c)
    {
        c.color="black";
        c.num = 8;
    }
}

//java基础视频教程第05天-06-面向对象(封装概述)
/*
    本节课主要讲解了面向对象的第一大特性封装Encapsulation的概述
    封装是指将不需要对外提供的属性和实现细节隐藏，仅对外提供公共访问方式

*/

 

//java基础视频教程第05天-07-面向对象(封装private)
/*
    本节课主要讲解了封装的一种表现形式private
    private用于修饰类中成员(成员变量，成员函数)，被权限修饰符private修饰之后表示这个成员私有化，
    私有只能在本类中访问，外部访问通过提供的对外的公共方法
    之所以提供private将类中的成员封装，提供对外访问方法访问，是为了避免直接访问类中成员导致的安全问题
    通过提供对外方法访问，这样可以加入逻辑判断语句，加强了代码的安全性

    注意：成员变量在堆内存中，有默认的初始化值，所以成员变量一建立可以不对它进行初始化就可以用
    而局部变量在栈内存中，局部变量一建立必须初始化才可以
*/
class Person
{
    private int age;
    public void setAge(int a)
    {
        if(a>0&&a<140)        //加入逻辑判断提高代码的健壮性,避免了直接访问传入负值的情况
        {
            age = a;    //这里没学到this，只能暂时这样写了
        }
        else
            System.out.println("非法年龄");
    }
    public int getAge()
    {
        return age;
    }
    public void run()
    {
        System.out.println("age="+age);
    }
}
class PersonDemo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
            p.setAge(110);
            p.getAge();
            p.run();
             
    }
}

//java基础视频教程第05天-08-面向对象(构造函数)
/*
    本节课主要讲解了构造函数的特点，作用，重写，注意事项以及与一般方法的区别，还有就是什么时候定义构造函数
    1.构造函数的特点：
    (1).构造函数的名称和类名相同
    (2).构造函数不用定义返回值
    (3).构造函数内部不可写return语句
    2.构造函数的作用：
    构造函数是用于给对应的对象初始化用的，不同的对象对应相应的初始化动作。
    3.构造函数也是函数，也是类中的成员，所以它具有函数的特点重写
    4.构造函数的注意事项
    一个类中如果没有写任何构造函数，系统会自动添加一个看不见的空参数的构造函数，当你定义了构造函数之后这个默认的构造函数就会被替代
    5.构造函数与一般函数的区别
    (1).构造函数是当对象一建立就会运行，而一般方法是对象调用才会运行
    (2).构造函数只运行一次，而一般方法可以被调用多次。
    6.什么时候定义构造函数
        当我们在描述事物时，事物一产生就需要有一些特有的属性和行为，我们将这些属性和行为定义在构造函数中
        比如人一出生就得有年龄，姓名和苦的行为
*/
class Person
{
    private String name;
    private int age;
    Person()                    //自定义了构造函数之后系统默认的构造函数就被替代，如果此处注释掉这个构造方法就会出错，因为默认的空参数构造函数被自定义的构造函数替代，看参数的对象初始化无法完成就会报错
    {
        System.out.println("name="+name+",age="+age);
    }
    Person(String name)            //构造函数的重载
    {
        System.out.println("name="+name+",age="+age);
    }
    Person(String name,int age)        //构造函数的重载
    {
        System.out.println("name="+name+",age="+age);
    }
    public void setName(String n)        //一般方法和构造方法的不同在于一般方法可以被调用多次，而构造方法只能在对象建立时运行
    {
        name = n;
    }
    public String getName()
    {
        return name;
    }

}
class PersonDemo1 
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        Person p1 = new Person("lilei");
        p1.setName("lucy");                //一般方法的好处在于后期对对象的属性进行多次更改
        System.out.println(p1.getName());
        Person p2 = new Person("lilei",32);

    }
}

//java基础视频教程第05天-09-面向对象(构造代码块)
/*
    本节课主要讲解了构造代码块的作用，以及与构造函数的区别
    1.构造代码块的作用
        构造代码块用于给所有对象初始化用的，就好像所有孩子出生都会哭一样
    2.构造代码块和构造函数的区别
        构造函数是给对应的对象初始化用的，而构造代码块是给所有对象进行初始化用的，而且它比构造方法先运行
        构造函数就相当于孩子出生（初始化）时，孩子一出生，有的孩子既没有名字也没有年龄，有的孩子一出生就有了姓名，但是不年龄，有的孩子一出生既有姓名又有年龄
        而构造代码块相当于每个孩子出生都会哭
*/
class Person
{
    private String name;
    private int age;
    {
        System.out.println("cry....");        //每个孩子一出生都会哭
    }
    Person()                                //既没有姓名也没有年龄的孩子
    {
        System.out.println("name="+name+",age="+age);
    }
    Person(String name)                        //有姓名但没有年龄的孩子
    {
        System.out.println("name="+name+",age="+age);
    }
    Person(String name,int age)                //既有姓名也有年龄的孩子
    {
        System.out.println("name="+name+",age="+age);
    }
}
class PersonDemo2
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        Person p1 = new Person("lilei");        
        Person p2 = new Person("lilei",32);
    }
}

//java基础视频教程第05天-10-面向对象(this关键字)
/*
    本节课主要讲解了在一个函数中局部变量和成员变量的名称相同时的一些注意事项，以及this关键字代表什么
    1.当一个函数中局部变量和成员变量相同时
        当一个函数中局部变量和成员变量相同时，局部中有就在局部中取，局部中没有就到外边去取
    2.this关键字代表什么
        简单点说，this关键字代表哪个对象在调用this所在的函数，this就代表哪个对象
*/
class Person
{
    private String name;
    private int age;
    Person(String name)
    {
        this.name = name;                        //当没有加this关键字时，这里的name代表的是局部变量的name，局部中有就用局部中的，局部中没有就用局部之外的，其实这里如果不加this关键字就相当于自己给自己赋值，比如 int x = 1;x=x;
    }
    Person(String n,int a)
    {
        name =n;            //这里局部变量和成员变量没有重名，就能区别开来，如果当n也为name就会局部中有就用局部中的变量，
        age= a;
    }
    public void speak()
    {
        System.out.println("name="+this.name+",age="+this.age);            //其实可以不加this的，加上就能够更加清晰
        this.show();                                //其实调用方法也是对象调用，这里加上this就可以更加清楚的看见
    }
    public void show()
    {
        System.out.println(this.name);
    }
}
class PersonDemo3
{
    public static void main(String[] args) 
    {
        Person p = new Person("Lily");
        Person p1 = new Person("Lucy",33);
        p1.speak();
    }
}

//java基础视频教程第05天-11-面向对象(this关键字的应用)
/*
    本节课主要讲解了this关键在应用
        当定义类中功能时，类中的函数内部用到了本类对象，这时为了区分调用这个函数的对象和传入的本类对象，就用到了this关键字
        但凡本类功能内部使用到了本类对象，就要用到this关键字
*/
/*
    需求：定义一个功能比较是否为同龄人
*/
class Person
{
    private int age;
    Person(int age)
    {
        this.age = age;
    }
    public boolean compare(Person p)        //该方法用到了本类对象，所以要用关键字this。
    {
        return this.age==p.age;        //this代表调用这个方法的这个对象p1
    }
}
class PersonDemo4
{
    public static void main(String[] args) 
    {
        Person p1 = new Person(22);
        Person p2 = new Person(34);
        boolean b = p1.compare(p2);
        System.out.println(b);
    }
}

//java基础视频教程第05天-12-面向对象(this关键字在构造函数间的调用)
/*
    本节课主要讲解了构造函数之间用this语句调用，并且this语句只能放在构造函数的第一行，
    注意：一般函数不能调用构造函数，
    并且还要注意，构造函数通过this语句调用其它构造函数时要把this语句放在构造函数的第一行，否则会出错，
    因为你把this语句放在不是第一行的话，你传入的值并不是你想要的值。
    总而言之，初始化中如果还有初始化动作就应该先执行初始化动作
    还要注意一点，构造函数之间不能互相调用，否则是死循环
*/
class Person
{
    private String name;
    private int age;
    Person()
    {
        //this(name);        还要注意一点，构造函数之间不能互相调用，否则是死循环    
    }
    Person(String name)
    {
        this();                //继续调用构造函数
        this.name = name;
        //this.name = "haha";
    }
    Person(String name,int age)
    {
        //this.name = name;            //this(name)必须放在构造函数的第一行，如果你没有放在第一行的话，就会出现你赋的值和你得到的值不同，因为你赋了一个值之后，然后你在去调用构造函数，构造函数内部可能赋的值又不一样，这样导致你赋的值和你得到的值不一样
        this(name);                //构造函数之间调用用this语句,这个this代表调用这个方法的对象p1
        this.age = age;
    }
    public void show()
    {
            System.out.println(name+"--"+age);
    }
}
class PersonDemo5
{
    public static void main(String[] args) 
    {
        Person p1  = new Person("lilei",22);
        p1.show();
    }
}

//java基础视频教程第06天-01-面向对象(static关键字)
/*
**********************************************************************************************************************************
    本节课为重点章节
    本节课主要讲解了static关键字
    1.概述：
    (1).static是一个修饰符，用于修饰成员(成员变量，成员函数)，被static修饰的成员存在于共享区中
    (2).被static修饰的的成员，除了可以被对象调用外，还可以直接被类名调用
    (3).对象特有的数据随着类走，对象共享的数据存放在共享区，可以被所有对象调用
    2.被static修饰的成员的特点
    (1).随着类的加载而加载
    (2).优先于对象存在
    (3).被所有的对象所共享
    (4).可以直接被类名调用
    3.实例变量和类变量的区别
    (1).存放位置
    (2).生命周期
    4.静态使用注意事项
    (1).静态方法只能访问静态成员，非静态成员既可以访问静态成员也可以访问非静态成员
    (2).静态方法中不可以出现this，super关键字，因为，this，super代表的是对象，而静态方法优先于对象存在，它的内部是不可以出现对象的。
    5.静态的利和弊
    利处：把对象共享的数据单独存储到共享区中，不必每个对象都建立一个，节约的内存空间，类名可以直接调用
    弊处：声明周期过长，访问出现局限性(静态虽好，只能访问静态)
**********************************************************************************************************************************
*/
class Person
{
    String name;
    static String country = "CN";            //将对象共享的数据存放到数据共享区中，每个对象都可以调用
    public static void show()
    {
        //System.out.println(name);        注意静态方法中不能出现非静态成员，因为非静态成员name是随着对象的建立而存在的，而静态方法先与对象存在，就会访问不到对象的非静态成员
        System.out.println("----"+country);
    }
}
class StaticDemo
{
    public static void main(String[] args) 
    {
        Person p = new Person();
        p.name = "哈利";
        p.show();            //对象也可以访问静态方法
        System.out.println(Person.country);        //类名直接调用静态字段
        Person.show();                            //类名直接调用静态方法
    }
}

//java基础视频教程第06天-02-面向对象（main函数）
/*
    本节课主要讲解了主函数的结构以及虚拟机在调用主函数时传入的数据
    主函数的结构：
    public表示主函数访问权限最大
    static表示主函数随着类的加载就已经存在了
    void表示主函数没有返回值
    main是主函数的名称，主函数是一个特殊的函数，main可以被jvm识别
    String[] args是函数的参数，这个参数是一个字符串类型的数组

    JVM在调用主函数时传入的参数是一个长度为0的字符串数组new String[0]
    注意一点javac命令底层调用的是编译器，而java命令底层调用的虚拟机
    既然jvm在调用主函数时传入了一个空参数的字符串数组，那么我们也可以自己通过jvm想主函数传值
    java MainDemo xixi haha hehe heihei hiahia

*/
class MainDemo
{
    public static void main(String[] args) 
    {
        System.out.println(args);            //打印出[Ljava.lang.String;@330cdec1，这段话表示jvm传递的是一个字符串数组
        System.out.println(args.length);        //打印出0，表示这个数组长度为0
    }
}

 

//java基础视频教程第06天-03-面向对象(静态什么时候使用)
/*
    本节课主要讲解了什么时候使用静态成员
    1.什么时候定义静态变量(类变量)
    当对象中出现共享数据时，该数据可以定义成静态数据，而对象的特有数据要定义成静态存在堆内存中
    2.什么时候定义静态函数
    当方法中没有使用到非静态数据时，就把该函数定义成静态的

*/
class Person
{
    String name;
    static String country ="CN";        //country是每个人都共有的数据，没必要每人都建立一个，把它作为静态数据村放到进数据区，任何对象都可以调用它
    public static void show()
    {
        System.out.println("haha");        //由于这个方法没有用到任何非静态的数据，所以就可以把它定义成静态方法
    }

}
class MainDemo1
{
    public static void main(String[] args) 
    {
        System.out.println(Person.country);
        Person.show();
    }
}

 

*************************

中间缺失稍后补上

*************************

//java基础视频教程第09天-01-面向对象(内部类访问规则)
/*
 3     本节课主要讲解了内部类的访问规则，主要讲解以下几点
 4     1.非静态内部类访问外部类的成员
 5         非静态内部类可以直接访问外部类的成员，包括私有成员，这是因为内部类持有外部类的引用,外部类.this（孙悟空在牛魔王的肚子里可以直接访问牛魔王的心脏）
 6     2.外部类访问非静态内部类的成员(非静态内部类成员都不是静态的，因为非静态内部类是外部类的一个成员，只有实例对象才能生成，而静态成员是随着类加载就存在了，
 7         如果你非静态内部类中有静态成员的话就会出现先后矛盾)外部类想访问非静态内部类成员，必须建立非静态内部类对象，通过非静态内部类对象调用内部的成员
 8         （牛魔王要访问孙悟空的心脏必须先见到孙悟空才可以访问）
 9     3.外部其它类直接访问非静态内部类成员(非静态内部类成员必须是非静态的)
10         非静态内部类在外部类的成员位置上，外部其它类想访问非静态内部类成员，必须先有外部类的对象，然后用外部类的对象去调用内部类对象，然后再去调用非静态内部类的成员
11         Outer.Inner in = new Outer().new Inner();        //注意那个点
12     注意点：
13     内部类既然是类的成员就可以被成员修饰符private，static修饰，
14     所以在面试时，如果面试官问你类可以被private修饰吗，你要肯定加确定的说能
15     前提是在这个类是内部类
*/
class Outer
{
    private int x = 4;            //外部成员
    class Inner
    {
        private int x =6;        //内部成员
        static String s = "haha";
        public void function()
        {
            int x = 3;            //内部局部成员
            System.out.println(x);                    //当局部变量名和成员变量名相同时，java会采用就近原则，局部中有就选用局部中的，局部没有才选用局部外的
            System.out.println(this.x);                //内部类访问本类中的成员加上this引用
            System.out.println(Outer.this.x);        //内部类持有外部类的引用，所以可以访问外部类的成员
        }
    }
    public void method()        //外部类想访问内部类成员必须建立内部类对象
    {
        Inner in = new Inner();
        in.function();
    }
}
class InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method();            

        Outer.Inner in = new Outer().new Inner();        //注意那个点
        in.function();

    }
}

//java基础视频教程第09天-面向对象（静态内部类）
 2 /*
 3     本节课主要围绕着静态内部类讲解了五点
 4     1.内部类被成员修饰符static修饰后，内部只能访问外部类的静态数据，出现的访问局限()
 5     2.外部类在成员位置上建立非静态方法去访问静态内部类中的成员(成员包括静态成员和非静态成员)
 6         (1).外部类在成员位置上建立非静态方法访问静态内部类中的非静态成员通过建立方法来new一个静态内部类的对象再去访问静态内部类中的非静态成员
 7         (2).外部类在成员位置上建立非静态方法访问静态内部类中的静态成员，外部类类名调用静态内部类类名，然后静态内部类类名调用它内部的静态成员
 8     3.外部类在成员位置上建立静态方法去访问静态内部类中的成员和2相同，只不过在外部其它类中不用建立外部类的对象，直接可以通过外部类名调用其成员位置上的静态方法即可
 9     4.外部其它类中访问静态内部类中的静态成员
10         可以通过两级类名直接调用静态成员
11     5.外部其它类中访问静态内部类中的非静态成员
12         先用外部类名调用内部类类，然后建立内部类对象，通过内部类对象去访问非静态成员
13     注意两点：
14         (1).当内部类中定义了静态成员，这个内部类必须也是静态的，因为内部类是外部类的一个成员变量，如果这个内部类是一个非静态的话，
15             就会随着实例化对象才会出现，但此时如果它内部有静态成员的话，静态成员是随着类建立的，比对象先建立，那么必定就会出现先后矛盾错误，
16             所以内部类当中定义了静态成员，这个内部类也必须是一个静态的内部类
17         (2).当在外部类的成员位置上建立静态方法访问内部类成员时，也必须要求内部类是静态的。因为外部类成员位置上的这个方法是静态的，是随着类的加载而加载，
18             这个静态方法要访问内部类成员必须建立内部类对象才能访问，如果此时访问的内部类是一个非静态的话，建立的对象就必须在这个静态方法加载之后才会出现
19             这也会导致先后矛盾错误，所以在外部类成员位置上建立静态方法访问内部类成员，也必须要求这个内部类是静态的
20 */
class Outer
{
    private static int x = 9;
    static class Inner
    {
        public static int y=7;
        public void function()                //这个只是一个普通的方法，没有用到非静态数据的方法
        {
            System.out.println(x);            //静态内部类只能访问静态数据，出现访问局限
        }
        public static void show()
        {
            System.out.println("haha");
        }
    }
    public void method()            
    {
        new Inner().function();        //外部类建立非静态方法来访问静态内部类中的非静态成员
        System.out.println(Inner.y);    //外部类可以通过调用静态内部类的类名，然后静态内部类类名调用它内部的静态成员
    }
    public static void method1()
    {
        new Inner().function();
        System.out.println(Inner.y);
    }
    
}
class InnerClassDemo1
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method();
        
        Outer.method1();

        System.out.println(Outer.Inner.y);            //外部其它类访问静态内部类中的静态属性
        Outer.Inner.show();                            //外部其它类访问静态内部类中的静态方法

        new Outer.Inner().function();                //外部其它类访问静态内部类中的非静态方法，通过外部类名调用内部类，然后建立静态内部类对象，通过静态内部类对象去调用它的非静态方法
    }
}

 

//java基础视频教程第09天-03-面向对象(内部类定义原则)
/*
    本节课主要讲解内部类什么时候用
        当描述事物时，事物内部还有事物，内部的事物就用内部类来描述,内部的事物不需要被访问就私有化，想要访问内部类就提供公共对外方法访问
        比如人，人的身体内部还有心脏等各种器官，这些器官就用内部类来描述，器官没有必要暴露，就把它封装起来，要想访问就通过提供对外的方法访问
*/
class Body
{
    private class Xinzang
    {
        
    }
    public void getXinZang()
    {
        new Xinzang();
    }
}

 

//java基础视频教程第09天-04-面向对象(匿名内部类)
/*
    这节课内容很多，分四个段来学习，这段主要讲了局部内部类，主要讲3点
    1.局部内部类不可以被成员修饰符static，private修饰，因为它是局部成员，不是成员变量了
    2.局部内部类中的成员也不可以被static修饰，因为当内部类中有静态成员，那个这个内部类也必须是静态内部类，
        而局部内部类不能被static修饰，所以推出局部内部类中的成员不可以被static修饰
    3.局部内部类访问自己所在函数中的局部变量时，这个局部变量必须加上final关键字
        至于为什么要加final，网上找了一下答案：
        java要求所有被局部内部类访问的局部变量都是用final修饰是因为：
        对于普通局部变量他的作用域就是该方法内，当方法结束该局部变量就随之消失；
        但局部内部类可能产生隐式的“闭包”，闭包将使得局部变量脱离他所在的方法继续存在。
*/
class Outer
{
    private int x = 2;
    public void method(final int z)        //z是局部变量，方法一调用完z就会消失，final只是暂时锁定z，z是有生命周期的
    {
        final int y = 1;
        class Inner                    //局部内部类不可以被成员修饰符private，static修饰，因为它不是成员变量
        {
            public void show()        //局部内部类中的成员也不可以被static修饰，因为内部类中如果有静态成员，那么这个内部类也必须是静态内部类，然而在局部位置上的内部类却不可以被static修饰，所以局部内部类中的成员不可以被static修饰
            {
                System.out.println(Outer.this.x);        //局部内部类任然可以访问外部类中的成员变量，因为局部内部类任然持有外部类成员的引用
                System.out.println(y);                    //局部内部类要访问所在方法内的局部变量，这个变量必须被final关键字修饰。
                System.out.println(z);                //由于z是局部变量，虽然加了final，但是由于是局部变量，方法调用完在就消失了，然后重新付一次值，所以这里的final没有永远锁定z，只是暂时锁定
            }
        }
        new Inner().show();            //局部内部类必须建立对象才能调用它的方法
    }
}
class InnerClassDemo2
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method(5);
        out.method(4);
    }
}
 

//java基础视频教程第09-04-面向对象（匿名内部类）
/*
    本节课主要讲解了匿名内部类的五点
    1.匿名内部类其实就是内部类的简写格式
    2.匿名内部类的前提是继承一个类或者实现一个接口
    3.匿名内部类的格式：new 父类名(或者接口名)(){实现接口方法和子类特有的方法};
    4.匿名内部类其实是一个匿名对象，是父类或者接口的子类对象
    5.匿名内部类的好处作用是简化了书写，但是它有两点不好
        (1),当接口中抽象方法多了的时候，用匿名内部类格式很繁琐
        (2),当给你匿名内部类添加一个父类引用变量时，你想通过父类引用调用自己的方法是不可以的。
*/
interface AbsMethod
{
    void show();
}
class Outer
{
    private String str = "haha";
    /*
    class Inner implements AbsMethod            //内部类也可以实现和继承
    {
        public void show()
        {
            System.out.println(Outer.this.str);
        }
        public void run()
        {
            System.out.println("heihei");
        }
    }
    */
    public void getInner()
    {
        /*
        Inner in = new Inner();
        in.show();
        in.run();
        */
        
        AbsMethod abs = new AbsMethod()            //匿名内部类，引用采用多态
        {
            public void show()
            {
                System.out.println(Outer.this.str);
            }
            public void run()
            {
                System.out.println("heihei");
            }
        };
        abs.show();
        //abs.run();            //注意父类中没有run方法，所以父类引用不能调用run方法
    }
}
class InnerClassDemo3
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.getInner();
    }
}

//java基础视频教程第09天-04-面向对象（匿名内部类练习）
/*
    本节课练习一个补充题
    interface Inter
    {
        void method();
    }
    class Test
    {
        //补足代码，通过匿名内部类
    }
    class InnerClassTest
    {
        public static void main(String[] args)
        {
            Test.function().method();    //分析：Test.function()表示function是一个静态方法，
                                            而静态方法能调用method方法表示function()返回的是一个对象，
                                            联系上面一个接口中有一个method方法，就可以想到在function中返回的是一个
                                            Inter类型的子类对象。
                                        
        }
    }
*/
interface Inter
{
    void method();
}
class Test
{
    /*
    static class Demo implements Inter
    {
        void method()
        {
            System.out.println("haha");
        }
    }
    */
    //补足代码，通过匿名内部类
    public static Inter function()
    {
        /*
        return new Demo();
            
        */
        return new Inter(){
            public void method()
            {
                System.out.println("haha");
            };
        }
    }
}
class InnnerClassTest
{
    public static void main(String[] args) 
    {
        Test.function().method();
    }
}