JAVA web基础-内部类

1内部类分类

1.成员内部类
2.局部内部类
3.匿名内部类
共性：-内部类仍然是一个独立的类，在编译之后会，内部类会被编译成独立的.Class文件，但是前面冠以外部类的类名和$符号。
-内部类不能用普通的方式访问，内部类是外部类的一个成员，因此内部类可以自由的访问外部类的成员变量，无论是否是private。

2.成员内部类

/*
 * 成员内部类：
 *      在类的成员位置，和成员变量个方法位置一样。
 *      在内部类中，可以直接访问外部成员，包括私有方法。
 * */

import org.junit.Test;

public class InnerDemo {
    @Test
    public void test(){
    //调用方法一：
//      Outer outer = new Outer();
//      outer.method();
    //调用方法二：
        Outer.Inner io = new Outer().new Inner();
        io.function();

    }
}

class Outer{
    private int num = 10;

    public void method(){
        Inner inner = new Inner();
        inner.function();
    }

    class Inner{
        public void function(){
            System.out.println("function" + num);
        }
    }
}

3.成员内部类的修饰符

/*
 * 成员内部类的修饰符：
 *      权限修饰符：public、protected。不能加private，则无法在其他类中访问。
 *      
 *      可以使用static修饰成员内部类，不用在创建外部类的对象了。
 *      我们可以使用abstract、finally修饰内部类。
 * 
 * */
public class InnerClassdemo02 {
    public static void main(String[] args) {
        Outer2.Inner2 io = new Outer2.Inner2();
        io.function();

        Outer2.Inner2.function();

    }
}

class Outer2{
    private int num = 10;
    public void mehod(){

    }

     static class Inner2{
        public static void function(){
            System.out.println("function");
        }
    }
}

4 局部内部类

/*
 *局部内部类：
 *      在方法内，出了方法之后就无法使用。
 * 
 * */
public class InnerClassdemo02 {
    public static void main(String[] args) {

        Outer2 outer2 = new Outer2();
        outer2.mehod();
    }
}

class Outer2{
    private int num = 10;
    public void mehod(){
        class Inner2{
            public void function(){
                System.out.println("function");
            }
        }

        Inner2 inner2 = new Inner2();
        inner2.function();

    }

}

5.匿名内部类

/*
 *匿名内部类：
 *      可以把匿名内部类看成是一个没有名字的局部内部类。
 *      定义在方法中，
 *      必须在定义匿名内部类的时候创建对象
 * 格式：
 *      new classname/interface(){
 *          如果是创建了继承这个类的子类对象，我们可以重写父类的方法。
 *          如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法。
 *      };
 * 
 * 原理：而是创建了继承这个类的子类对象，创建了实现这个接口的子类对象。
 * */
public class InnerClassdemo02 {
    public static void main(String[] args) {

        Outer2 outer2 = new Outer2();
        outer2.method();
    }
}


interface Inner{
    public void function();//接口中默认的方法是abstract。
}


class Outer2{

    public void method(){
        new Inner(){

            @Override
            public void function() {
                // TODO Auto-generated method stub
                System.out.println("function");
            }

        }.function();


//      多态，向上转型;第二种，变量接受。
        Inner inner = new Inner(){

            @Override
            public void function() {
                // TODO Auto-generated method stub
                System.out.println("function");
            }

        };

        inner.function();
        inner.function();

    }
}

6.匿名内部类作为参数进传递

/*
 * 匿名内部类的应用场景
 *      作为参数进行传递
 * 
 * */
public class InnerClassdemos {
    public static void main(String[] args) {
        method(new Dog());
        method(new Cat());

//      如果cat或者dog只执行一次，可以作为参数进行传递。
    method(new Animals() {

        @Override
        public void eat() {
            // TODO Auto-generated method stub
            System.out.println("cat eat fish");
            }
        }
    );


    }

    public static void method(Animals animals) {
        animals.eat();
    }


}