内部类的使用与概念！

　　如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。

例如； 身体和心脏的关系，又如：汽车和发动机的关系。

 

 

分类；

1，成员内部类。

2，局部内部类（包含匿名内部类）

 

成员内部类的定义格式：
 修饰符 class 外部类名称 {

       修饰符 class 内部类名称 { 

         ///。。。

        }

     ///。。。

}

 

演示外部类和内部类。

public class Body {//外部类

    public class Heart {//成员内部类

        //内部类的方法
        public void beat() {
            System.out.println("心脏跳动，蹦蹦蹦！");
            System.out.println("我叫：" + name);//正确写法！
        }

    }

    //外部类的成员方法
    private String name;


    //外部类的方法
    public void methodBody() {
        System.out.println("外部类方法");
    }

    public String getName() {
        return name;
    }

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

 

 

注意：内用外，随意访问。   外用内，需要内部类对象。

=============================================

成员内部类的使用；

 如何使用成员内部类？有两种方法；

1，【间接方法】在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。

2，【直接方法】  公式：

一般创建对象的常用公式；类名称 对象名 =  new  类名称（）；

直接调用内部类的公式； 【外部类名称  .  内部类的名称   对象名 = new 外部类名称()  .   new 内部类名称()；】

记忆技巧：【外点内】

public class lei {
    public static void main(String[] args) {

        //间接方法
        Body body = new Body();//外部类的对象
        //通过外部类的对象，调用外部类方法，里面间接在使用内部类Heart。
        body.methodBody();

        System.out.println("=========================");

        //直接方法
        Body.Heart heart = new Body().new Heart();
        heart.beat();

    }

}

 

 

 

 

 

 

内部类的同名变量访问：

如果出现重名现象，那么格式是：【外部类名称 . this . 外部类成员变量名】

 

public class Outer {

    int num = 10;//外部类的成员变量

    public class Inner/* extends Object*/ {

        int num = 20;//内部类的成员变量

        public void methodInner() {

            int num = 30;//内部类方法的局部变量

            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//内部类的成员变量
            System.out.println(Outer.this.num);//外部类的成员变量
        }


    }
}

 

调取方法；

 Outer.Inner inner = new Outer().new Inner();

inner.methodInner(); 

 

 

 

 

 

 局部内部类定义；

如果一个类是定义在方法内部的，那么这就是一个局部内部类。

局部提点：只有当前所属的方法才能使用它，出来这个方法外面就不能用了。

 

 

小节一下类的权限修饰符：

public   >   protected   >   (default)   >   private

定义一个类的时候，权限修饰符规则：

1，外部类： Public /  （default）

2，成员内部类：public   /   protected   /   (default)   /   private

3，局部内部类：什么都不能写

 

public class OuterA {

    public void methodOuterA(){


        class Inner{//局部内部类
            int num = 10;
            public void methodInner() {

                System.out.println(this .num); //调用局部内部变量。

            }
        }
        Inner inner = new Inner();
        inner.methodInner();

    }



}

 

 

 

  局部内部类的final问题：

 

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】

备注；从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：

1，new出来的对象在堆内存当中。

2，局部变量是跟着方法走的，在栈内存当中。

3，方法运行结束之后，立刻出栈，局部变量就会立刻消失。

4，但是new出来的对象会在堆中持续存在，直到垃圾回收消失。

public class OuterA {

    public void methodOuterA(){


        class Inner{//局部内部类
           final int num = 10;
            public void methodInner() {

                System.out.println(this .num); //调用局部内部变量。

            }
        }
        Inner inner = new Inner();
        inner.methodInner();

    }

}

 

 在第7行里 那个final 可以不写，但是 有一个重要的信息 就是和final一样的作用。

 

 

 

 

 

匿名内部类：

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，

那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

 

匿名内部类的定义格式：

接口名称 对象名 = new 接口名称 （） {

                    //覆盖重写所有抽象方法

  };

public class DemoMain {
    public static void main(String[] args) {
   /*     MyInterface obj = new MyInterfaceImpl();
        obj.method();
*/

        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！"
                );

            }
        };
        obj .method();


    }
}

 

 

 

 

 

 

匿名内部类的注意事项；

 

对格式“ new 接口名称（）{....} ”进行解释：
1，new代表创建对象的动作。

2，接口名称就是匿名内部类需要实现那个接口。
3，{。。。}这才是匿名内部类的内容。

 

另外还有注意几点问题；

1，匿名内部类，在【创建对象】的时候，只能使用唯一 一次。

如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。

2，匿名对象，在【调用方法】的时候，只能用唯一 一次。

如果希望同一个对象，调用多次方法，那么必须给对象起个名字。

3，匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

强调：匿名内部类和匿名对象不是一回事！！！

 

 

public class DemoMain {
    public static void main(String[] args) {
   /*     MyInterface obj = new MyInterfaceImpl();
        obj.method();
*/

        MyInterface obj = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！ 111- A");

            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！ 222- A");

            }
        };
        obj.method1();
        obj.method2();
        System.out.println("-----------------------------------");

        //使用了匿名内部类，而且省略了对象名称，也是匿名对象。
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！ 111- B");

            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！ 222- B");

            }
        }.method1();
        //因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象

        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！ 111- B");

            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！ 222- B");

            }
        }.method2();
        
    }
}

     

 

 

类作为成员变量类型；

 

成员变量不但可以基本类型，还可以用任何一种类class。

 

本节内容主要讲了是 ：在成员变量里，也可以用类来当变量类型。

如下图里的 "private Weapon wwapon"  也可以用来变量使用。

 

普通类；

 

public class Hero {

    private String name;//英雄的名子
    private int age; //英雄的年龄
    private Weapon weapon;//武器

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

    public void attack() {
        System.out.println("年龄为" + age + "的" + name + " 用" + weapon.getCode() + "攻击敌方。");
    }

    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 Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

 

类；

这个类是单独写出啦的，里面有构造方法和get/set方法。可以理解定义一个类。给Hero 用的。

 

public class Weapon {

    private String code; //武器的代号

    public Weapon() {

    }

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

 

 

输出：

 注意看  10/12行里的代码。

public class DemoMain {

    public static void main(String[] args) {
        //创建一个英雄角色
        Hero hero = new Hero();
        //为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);

        //创建一个武器对象
        Weapon weapon = new Weapon("AK-47");
        hero.setWeapon(weapon);

        hero.attack();


    }

}

 

 

 

 

 接口作为成员变量类型：

 利用skill做为成员变量类型

 

普通类：

public class Hero {

    private String name;//英雄的名称
    private Skill skill;//英雄的技能

    public Hero() {
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }


    public void attack() {
        System.out.println("我叫" + name + ", 开始施放技能:");
        
        skill.use();//调用接口中的抽象方法

        System.out.println("施放技能完成！");
    }

    public String getName() {
        return name;
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }

    public void setSkill() {
    }
}

 

 

 接口类；

public interface Skill {

public abstract void use();

} 

 

实现接口类 ；

public class SkillImpl implements Skill {
    @Override
    public void use() {
        System.out.println("Biu~biu~biu");
    }
}

 

 

 类：

有3种不同的实现方法

public class DemoGame {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("盖伦");//设置英雄的名称


        //设置英雄技能
/*
        hero.setSkill(new SkillImpl());//使用单独定义类的实现类  //方法 1
*/


/*
        //使用匿名内部类                      //方法2
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("Pia~pia~pia~");
            }
        };
        hero.setSkill(skill);
*/



        //进一步简化，同时使用匿名内部类和匿名对象 //方法3
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu~pia~Biu~pia");
            }
        });


        hero.attack();


    }
}

 

 

方法1的

 

 

方法2的

 

 

方法3的