内部类

匿名类

static修饰成员及访问

package com.ice.test00;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Animal {
    //成员变量
    int age;
    String name;

    //成员方法
    public void eat() {
        System.out.println("eat...");
    }

    /**
     * 被static修饰的变量：静态变量（类变量）
     * 被static修饰的方法：静态方法（类方法）
     * 静态变量和静态方法称为静态成员
     * 静态成员通过"类名.“访问（标准）或者”对象.“访问（非标准，不推荐使用）
     * <p>
     * static修饰的方法或代码块中不能使用this与super
     * static不能修饰构造器
     */
    //静态变量
    static char sex;
    static int foot;

    //静态方法
    public static void sleep() {
        System.out.println("sleep...");
    }

    public static void main(String[] args) {
        //通过”类名.“访问静态成员
        System.out.println(Animal.sex);
        System.out.println(Animal.foot);
        Animal.sleep();

        //通过”对象.“访问静态成员  非标准的，不推荐使用
        Animal a = new Animal();
        System.out.println(a.sex);
        System.out.println(a.foot);
        a.sleep();
    }
}

static应用

package com.ice.test;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class People {
    private String name;
    private int age;
    private static String city;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", city='" + city + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

package com.ice.test;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test02 {
    public static void main(String[] args) {

        People p1 = new People("max", 23);
        p1.setCity("北京");
        System.out.println(p1);

        People p2 = new People("小龙", 21);
        p2.setCity("贵阳");
        System.out.println(p2);

        People p3 = new People("小敏", 22);
        System.out.println(p3);
    }

}

static初始化块

package com.ice.test;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Count {
    public int number;

    private static int count;//用于计数

    //用于初始静态变量，先于构造器执行
    static {
        System.out.println("类加载时执行了并且被执行一次");
        count = 1;
    }

    public static int getCount() {
        return count;
    }

    public Count() {
        count++;
        number = count;
        System.out.println("构造器被执行");
    }
}

package com.ice.test;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test01 {
    public static void main(String[] args) {
        Count c = new Count();
        new Count();
        System.out.println(c.number);
    }
}

执行结果：

类加载时执行了并且被执行一次
构造器被执行
构造器被执行
2

单例设计模式

懒汉式

package com.ice.test01;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//懒汉式
public class SingleTon {
    public double r = Math.random();
    private static SingleTon single = null;

    //私有化构造器，不让其他类创建对象
    private SingleTon() {

    }

    //静态工厂：专门用来生产类的实例
    public static SingleTon getInstance() {
        if (single == null) {
            single = new SingleTon();
        }
        return single;
    }

}

饿汉式

package com.ice.test02;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 * 内部类：就是在一个类或方法中定义的类
 * 内部类实际也是一个类，可以有成员变量和成员方法
 * 分类：成员内部类，静态内部类，局部内部类，匿名内部类
 */
//饿汉式
public class SingleTon {
    public double r = Math.random();
    private static SingleTon single = new SingleTon();

    //私有化构造器，不让其他类创建对象
    private SingleTon() {

    }

    //静态工厂：专门用来生产类的实例
    public static SingleTon getInstance() {
        return single;
    }

}

package com.ice.test02;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test {

    public static void main(String[] args) {
        SingleTon single1 = SingleTon.getInstance();
        System.out.println(single1.r);
        SingleTon single2 = SingleTon.getInstance();
        System.out.println(single2.r);
    }
}

内部类的定义

public abstract class Animal {
    public abstract void eat();
}

public interface Inf1 {
    //启动
    public abstract void start();
}

public interface Inf2 {
    //开始
    public abstract void start();
}

public abstract class Other {
    public abstract void othereat();
}

package com.ice.test03;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//外部类
public class Outerclass extends Other implements Inf1 {
    public static int a = 0;

    @Override
    public void start() {//启动

    }

    @Override
    public void othereat() {

    }

    //内部类
    class InnerClass {
    }

    //内部类实现接口
    class InnerClassInf implements Inf2 {

        @Override
        public void start() {//开始

        }
    }

    //内部类继承抽象类
    class InnerClassAbstract extends Animal {

        @Override
        public void eat() {

        }
    }

}

类的内容

package com.ice.test04;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public abstract class OuterClass {
    int a;//成员变量
    static int b;//静态变量
    final static int C = 10;//常量

    {
        //初始化块
    }

    static {
        //静态初始化块
    }

    public OuterClass() {
        //构造器

    }

    public void fun1() {
        //成员方法

    }

    public static void fun2() {
        //静态成员方法

    }

    public abstract void fun3();//抽象方法

    class InnerClass {
        //内部类
        
    }

}

成员内部类

package com.ice.test05;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class OuterClass {
    int a = 10;//成员变量
    static int b = 20;//静态变量

    /**
     * 在外部类中访问成员内部类:new 内部类名().内部类对象
     */
    //成员方法
    public void fun() {
        System.out.println(new InnerClass().x);
    }

    //成员内部类
    class InnerClass {
        int x = 10;

        //        static int y=20;//内部类中不能存在静态成员

        /**
         * 在成员内部类中访问外部类：外部类类名.this.外部类对象
         * this在内部类中表示当前的内部类对象
         */
        public void fun() {
            System.out.println(OuterClass.this.a);
            System.out.println(this.x);
        }
    }
}

静态内部类

package com.ice.test06;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//外部类
public class OuterClass {

    //静态内部类
    public static class InnerClass {
        public static int a = 10;

        public static void fun() {
            System.out.println("statie fun...");
        }
    }

    public void test() {
        System.out.println(InnerClass.a);
    }
}

package com.ice.test006;

import com.ice.test06.OuterClass;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test {
    public void m() {
        System.out.println(OuterClass.InnerClass.a);
    }
}

局部内部类

package com.ice.test07;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class OuterClass {
    public int a = 10;

    public void fun() {
        //局部变量
        final int x = 100;
        /**
         * 局部内部类：定义在方法内部或参数位置
         * 作用域只在该方法内有效，不能使用权限修饰符
         */
        class InnerClass {
            public void test() {
                System.out.println(OuterClass.this.a);//访问外部类成员，通过“外部类名.this.外部对象

                System.out.println(x);//访问方法的局部变量，但是这个局部变量必须由final修饰
            }
        }
    }
}

匿名内部类

package com.ice.test08;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Animal {
    public void eat() {
        System.out.println("Animal...");
    }
}

package com.ice.test08;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 * 匿名内部类：
 * 1.在成员变量赋值时创建
 * 2.在方法内部定义并直接使用
 * 3.在方法参数位置创建
 */
//外部类
public class NoNameClass {
    Animal a = null;//声明引用对象时使用默认值null
    Animal a2 = new Animal();//声明引用变量时就创建对象

    /**
     * 1.在成员变量赋值时创建
     */
    //声明引用变量并创建匿名内部类对象 new 类名（）{}--->匿名内部类对象
    Animal a3 = new Animal() {
        @Override
        public void eat() {
            super.eat();
        }
    };

    /**
     * 2.在方法内部定义并直接使用
     */

    public void fun() {
        //匿名内部类--->匿名对象，用完一次就回收
        new Animal() {
        };
        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名内部类的eat方法");
            }
        };
        a.eat();
    }

    /**
     * 3.在方法参数位置创建
     *
     * @param a
     */
    public void m(Animal a) {

    }

    public static void main(String[] args) {
        new NoNameClass().m(new Animal() {//在方法参数位置创建

        });
    }
}

//普通类
public class Animal {
    public void sleep() {

    }
}

//抽象类
public abstract class Computer {

    public abstract void play();
}

//接口
public interface Mouse {
    public abstract void click();
}

package com.ice.test09;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class NoNameClass {
    //普通类实现匿名内部类
    Animal a = new Animal() {
        @Override
        public void sleep() {
            System.out.println("匿名内部类的sleep()方法");
        }
    };
    //抽象类实现匿名内部类：在匿名内部类中必须重写抽象方法
    Computer c = new Computer() {
        @Override
        public void play() {
            System.out.println("匿名内部类的play()方法");
        }
    };

    //接口实现匿名内部类:在匿名内部类中必须重写抽象方法
    Mouse m = new Mouse() {
        @Override
        public void click() {

        }
    };
}

使用匿名内部类作为参数传递

package com.ice.test10;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//普通类
public class Animal {
    public void sleep() {
        System.out.println("Animal sleep...");
    }
}

class Dog extends Animal {
    @Override
    public void sleep() {
        System.out.println("Dog sleep");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//抽象类
public abstract class Computer {
    public abstract void play();
}

class MyComputer extends Computer {
    @Override
    public void play() {
        System.out.println("MyComputer play...");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
//接口
public interface Mouse {
    public abstract void click();
}

class Lenovo implements Mouse {
    @Override
    public void click() {
        System.out.println("Lenovo click...");
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class NoNameClass {
    /**
     * 普通内部类作为参数时:可以传普通类对象、子类对象、匿名内部类对象
     */
    public void m1(Animal a) {
        a.sleep();
    }

    /**
     * 抽象类作为参数时：可以传递子类对象，匿名内部类对象
     *
     * @param c
     */
    public void m2(Computer c) {
        c.play();
    }

    /**
     * 参数作为接口时：可以传递实现类对象，匿名内部类对象
     *
     * @param m
     */
    public void m3(Mouse m) {
        m.click();
    }
}

package com.ice.test10;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test {
    public static void main(String[] args) {
        NoNameClass n = new NoNameClass();

        //调用参数为普通类的方法
        n.m1(new Animal());//Animal a=new Animal();
        n.m1(new Dog());//Animal a=new Dog();//向上转型
        n.m1(new Animal() {//Animal a=匿名内部类对象
            @Override
            public void sleep() {
                System.out.println("普通类实现匿名内部类");
            }
        });

        //调用参数为抽象类的方法
        n.m2(new MyComputer());//Computer c=new MyComputer 向上转型
        n.m2(new Computer() {
            @Override
            public void play() {
                System.out.println("抽象类实现匿名内部类");
            }
        });

        //调用参数为接口的方法
        n.m3(new Lenovo());//Mouse m=new Lenove();//向上转型
        n.m3(new Mouse() {
            @Override
            public void click() {
                System.out.println("接口实现匿名内部类");
            }
        });
    }

}

作业

1、内部类的使用：
（1）定义一个外部类Father，有成员变量name并赋一个初值。
（2）定义一个内部类Child，并定义一个getValue()方法，在方法中调用外部类Father的name变量。
（3）定义一个测试类，在测试类的main方法中创建Child对象，并调用getValue()方法

package com.ice.test11;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Father {
    private String name = "max";

    class Child {
        public void getValue() {
            System.out.println(Father.this.name);
        }
    }

    public void getValue() {
        Child c = new Child();
        c.getValue();
    }
}

package com.ice.test11;

/**
 * @author lucky_ice
 * 版权：****
 * 版本：version 1.0
 */
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.getValue();
    }
}