java基础(5)内部类

1 成员内部类的定义和使用

public class Outer {
    private String name;
    public class Inner {
        public void innerMethod(){
            System.out.println("heart beat:Pengpengpeng");
        }
    }

    public void method(){
        System.out.println("My name is:"+ name);
        Inner inner = new Inner();//要在里面创建内部类的对象
        inner.innerMethod();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();//new 外部类.new.内部类
        inner.innerMethod();

        System.out.println("===============");
        Outer outer = new Outer();
        outer.method();
    }
}

///////
heart beat:Pengpengpeng
===============
My name is:null
heart beat:Pengpengpeng
/////访问同名变量public class Outer {
    private String name;
    private int num=10;

    public class Inner {
        private int num = 20;
        public void innerMethod(){
            int num = 30;
            System.out.println("heart beat:Pengpengpeng");
            System.out.println("innerMethod-num:"+num);
            System.out.println("innerClass-num:"+this.num);
            System.out.println("outterClass-num:"+Outer.this.num);//要使用Outer.this
        }
    }

    public void method(){
        System.out.println("My name is:"+ name);
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.innerMethod();

        System.out.println("===============");
        Outer outer = new Outer();
        outer.method();
    }
}

/////

heart beat:Pengpengpeng
innerMethod-num:30
innerClass-num:20
outterClass-num:10
===============
My name is:null
heart beat:Pengpengpeng
innerMethod-num:30
innerClass-num:20
outterClass-num:10

2 局部内部类的定义和使用

/*
如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

定义格式:
修饰符 class 外部类名称 {
    修饰符 返回值类型 外部类方法名称(参数列表) {
        class 局部内部类名称 {
            // ...
        }
    }
}

小节一下类的权限修饰符:
public > protected > (default) > private
定义一个类的时候,权限修饰符规则:
1. 外部类:public / (default)
2. 成员内部类:public / protected / (default) / private
3. 局部内部类:什么都不能写
 */
class Outer {

    public void methodOuter() {
        class Inner { // 局部内部类
            int num = 10;
            public void methodInner() {
                System.out.println(num); // 10
            }
        }

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

}

3 局部内部类的final问题

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

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

原因:
1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的,在栈内存当中。
3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
 */
public class MyOuter {

    public void methodOuter() {
        int num = 10; // 所在方法的局部变量

        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }

}

4 匿名内部类

为什么要用匿名内部类:

以接口举例,当你使用一个接口时,似乎得做如下几步操作,
1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

我们的目的,最终只是为了调用方法,那么能不能简化一下,把以上四步合成一步呢?匿名内部类就是做这样的快
捷方式。

//定义一个接口
public interface MyInterface {
    public abstract void methodAbs();
}

//定义在main方法中定义匿名内部类,它需要实现接口
public class anonymousClass {
    public static void main(String[] args) {

        /*
        1.等号右边:是匿名内部类,定义并创建该接口的子类对象
        2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        MyInterface anonymous = new MyInterface() {
            @Override
            public void methodAbs() {
                System.out.println("I am an anonymous class");
            }
        };

        anonymous.methodAbs();
    }
}        

注意事项:

/*
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,
那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。

匿名内部类的定义格式:
接口名称 对象名 = new 接口名称() {
    // 覆盖重写所有抽象方法
};

对格式“new 接口名称() {...}”进行解析:
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}这才是匿名内部类的内容

另外还要注意几点问题:
1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。
如果希望多次创建对象,而且类的内容一样的话,那么就需要使用单独定义的实现类了。
2. 匿名对象,在【调用方法】的时候,只能调用唯一一次。
如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
3. 匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
强调:匿名内部类和匿名对象不是一回事!!!
 */
public class DemoMain {

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

//        MyInterface some = new MyInterface(); // 错误写法!

        // 使用匿名内部类,但不是匿名对象,对象名称就叫objA
        MyInterface objA = new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法!111-A");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法!222-A");
            }
        };
        objA.method1();
        objA.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();
    }

}

综合例子:接口作为成员变量的类型,如何给该成员变量赋值(如何实现该接口):

//接口作为成员变量的类型
public class Hero {

    private String name; // 英雄的名称
    private Skill 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 interface Skill {

    void use(); // 释放技能的抽象方法

}

//方法1所需要的接口的实现类
public class SkillImpl implements Skill {
    @Override
    public void use() {
        System.out.println("Biu~biu~biu~");
    }
}

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();
    }

}

原文地址:https://www.cnblogs.com/JohnTeslaaa/p/10294287.html

时间: 2024-10-13 03:32:36

java基础(5)内部类的相关文章

java基础之 内部类

Java中的内部类共分为四种: 静态内部类static inner class (also called nested class) 成员内部类member inner class 局部内部类local inner class 匿名内部类anonymous inner class 静态内部类Static Inner Class 最简单的内部类形式. 类定义时加上static关键字. 不能和外部类有相同的名字. 被编译成一个完全独立的.class文件,名称为OuterClass$InnerClas

Java基础(53):内部类(1)-----(转)

java中的内部类总结 内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类 如同一个人是由大脑.肢体.器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液.跳动) 显然,此处不能单方面用属性或者方法表示一个心脏,而需要一个类 而心脏又在人体当中,正如同是内部类在外部内当中 实例1:内部类的基本结构(常规内部类) 1 //外部类 2 class Out { 3 private int age = 12; 4 5 //内部类 6 class In

2.24 Java基础总结 ①内部类基础

内部类基础类里边再定义了类,可以是成员内部类,也可以是局部内部类(方法里边) 一.成员内部类①可以有访问修饰符②class文件名:外部类类名$内部类类名.class③就是一个完整的独立类④在本类任意非static的地方都可以new出来,但在第三方必用外部类对象.new的方式产生内部类Student s = outside.new Student():⑤静态内部类--特例在本类任意方法中可new出来,在第三方中药new出来,无需产生外部类对象,只需要用外部类类名. 的方法 二.局部内部类①不能有访

【java基础】内部类,局部内部类,匿名内部类、静态内部类、接口中的内部类

内部类: 1.定义在一个类中的内部类,内部类的实例化伴随着外围类所定义的方法来构造,内部类对象有外围类的隐式引用,所以内部类可以直接访问外围类的外围类的域,包括私有的,这是内部类的访问特权,所以比常规类功能更加强大. 2.内部类可以对同一个包中的其他类隐藏起来,不过可以通过 OuterClass.InnerClass来引用public声明的内部类. 局部内部类: 1.内部类挪到方法内部,与内部类相比,局部内部类不仅可以访问定义他们的外部类,还可以并且仅可以访问声明为final的局部变量. 2.类

Java基础:内部类

在某些情况下,把一个类放在另一个类的内部定义,这个定义在其他类内部的类就称为内部类.包含内部类的类被称为外部类.内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 . 根据类定义的位置和修饰符的不同,内部类可以分为: 成员内部类(包括静态成员内部类,非静态成员内部类) 方法内部类 匿名内部类 1 静态成员内部类 1.1 定义 package com.demo; public class Outer { private static Str

Java基础(10) - 内部类

存在意义1.内部类可以很好的实现隐藏一般的非内部类,是不允许有private与protected权限的,但内部类可以 2.内部类拥有外部类所有元素的访问权限 ,private修饰也能访问. 3.可实现多重继承 ,让多个内部类分别继承多个其他类,使外部类可以同时获取多个其他类的属性. 4.可以避免修改接口而实现同一个类中两种同名方法的调用.(外部类继承,让内部类实现接口)参考:https://www.jianshu.com/p/f0fdea957792 静态.非静态内部类的区别1.声明静态内部类中

JAVA基础知识|lambda与stream

lambda与stream是java8中比较重要两个新特性,lambda表达式采用一种简洁的语法定义代码块,允许我们将行为传递到函数中.之前我们想将行为传递到函数中,仅有的选择是使用匿名内部类,现在我们可以使用lambda表达式替代匿名内部类.在学习lambda表达式之前,建议各位看官先去学习一下匿名内部类(JAVA基础知识|内部类). stream提供了很多有用的api,方便了我们对集合的操作 一.lambda表达式 基本语法:(parameters) -> expression或(param

Java基础面试:集合、内部类、线程

package test; import java.util.Hashtable; import java.util.Map; public class test { public static String change(String param){ param=null; return param; } public static void main(String[] args) { String param1="p1"; param1=change(param1); Map ta

黑马程序员——java基础——内部类

 黑马程序员--java基础--内部类 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 内部类 如果A类需要直接访问B类中的成员,而B类又需要建立A类的对象.这时,为了方便设计和访问,直接将A类定义在B类中.就可以了.A类就称为内部类.内部类可以直接访问外部类中的成员.而外部类想要访问内部类,必须要建立内部类的对象. 内部类的访问规则 1,内部类可以直接访问外部类中的成员,包括私有. 之所以可以直接访问外部类中的成员,是因为内部类中持有

JAVA基础之包装类,static,final,abstract ,接口 和 内部类

包装类: 自jdk5之后,java就提供了自动装箱与自动拆箱功能,大大简化了基本类型与其包装类对象之间的转换过程,当然装换过程中要注意类型的匹配. public class IntAndInteger { public static void main(String[] args) { //自动装箱 Integer intObj = 5; Integer intObjj = 5; //自动拆箱 int a = intObj; //包装类实现基本变量与字符串的转换 String str = "12