JAVA内部类示例详解及练习

目录
  • 1 内部类概述
  • 2 特点
  • 3 练习 : 内部类入门案例
  • 4 成员内部类
    • 4.1 练习 : 被private修饰
    • 4.2 练习 : 被static修饰
  • 5 局部内部类
  • 6 匿名内部类

1 内部类概述

如果一个类存在的意义就是为指定的另一个类,可以把这个类放入另一个类的内部。
就是把类定义在类的内部的情况就可以形成内部类的形式。
A类中又定义了B类,B类就是内部类,B类可以当做A类的一个成员看待:

2 特点

1) 内部类可以直接访问外部类中的成员,包括私有成员

2) 外部类要访问内部类的成员,必须要建立内部类的对象

3) 在成员位置的内部类是成员内部类

4) 在局部位置的内部类是局部内部类

3 练习 : 内部类入门案例

创建包: cn.tedu.innerclass

创建类: TestInner1.java

package cn.tedu.innerclass;
/*本类用作测试内部类的入门案例*/
public class TestInner1 {
    public static void main(String[] args) {
        //3.创建内部类对象,使用内部类的资源
        /*外部类名.内部类名 对象名 = 外部类对象.内部类对象*/
        Outer.Inner oi = new Outer().new Inner();
        oi.delete();
        System.out.println(oi.sum);
        //4.调用外部类的方法--这样是创建了一个外部类的匿名对象,只使用一次
        new Outer().find();
    }
}
//1.创建外部类 Outer
class Outer{
    //1.1创建外部类的成员变量
    String name;
    private int age;
    //1.2创建外部类的成员方法
    public void find(){
        System.out.println("Outer...find()");
        //6.测试外部类如何使用内部类的资源
        //System.out.println(sum);--不能直接使用内部类的属性
        //delete();--不能直接调用内部类的方法
        /*外部类如果想要使用内部类的资源,必须先创建内部类对象
        * 通过内部类对象来调用内部类的资源*/
        Inner in = new Inner();
        System.out.println(in.sum);
        in.delete();
    }
    //2.创建内部类Inner--类的特殊成员
    /*根据内部类位置的不同,分为:成员内部类(类里方法外)、局部内部类(方法里)*/
    class Inner{
        //2.1定义内部类的成员变量
        int sum = 10;
        //2.2定义内部类的成员方法
        public void delete(){
            System.out.println("Inner...delete()");
            //5.测试内部类是否可以使用外部类的资源
            /*结论:内部类可以直接使用外部类的资源,私有成员也可以!*/
            System.out.println(name);
            System.out.println(age);
            /*注意:此处测试完毕需要注释掉,否则来回调用
            * 会抛出异常StackOverFlowException栈溢出异常*/
            //find();
        }
    }
}

4 成员内部类

4.1 练习 : 被private修饰

创建包: cn.tedu.innerclass

创建类: TestInner2.java

package cn.tedu.innerclass;
/**本类用来测试成员内部类被private修饰*/
public class TestInner2 {
	public static void main(String[] args) {
		/**怎么使用内部类Inner2的资源?*/
		//4.创建内部类Inner2对象进行访问
		//Outer2.Inner2 oi = new Outer2().new Inner2();
		//oi.eat();
		/**如果Inner2被private修饰,无法直接创建对象该怎么办?*/
		//7.创建外部类对象,间接访问私有内部类资源
		new Outer2().getInner2Eat();
	}
}
//1.创建外部类Outer2
class Outer2{
	//6.提供外部类公共的方法,在方法内部创建Inner2内部类对象,调用内部类方法
	public void getInner2Eat() {
		Inner2 in = new Inner2();//外部类可以访问内部类的私有成员
		in.eat();
	}
	//2.1创建成员内部类Inner2
	/**成员内部类的位置:类里方法外*/
	//5.成员内部类,被private修饰私有化,无法被外界访问
	private class Inner2{
		//3.创建内部类的普通成员方法
		public void eat() {
			System.out.println("我是Inner2的eat()");
		}
	}
}

总结: 成员内部类被Private修饰以后,无法被外界直接创建创建对象使用 所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

4.2 练习 : 被static修饰

创建包: cn.tedu.innerclass

创建类: TestInner3.java

package cn.tedu.innerclass;
/**本类用来测试成员内部类被static修饰*/
public class TestInner3 {
	public static void main(String[] args) {
		/**如何访问内部类的show()?*/
		//4.创建内部类对象访问show()
		//方式一:按照之前的方式,创建内部类对象调用show()
		//Outer3.Inner3 oi = new Outer3().new Inner3();
		//oi.show();
		//方式二:创建匿名内部类对象访问show()
		//new Outer3().new Inner3().show();
		/**现象:当内部类被static修饰以后,new Outer3()报错*/
		//6.用static修饰内部类以后,上面的创建语句报错,注释掉
		//通过外部类的类名创建内部类对象
		Outer3.Inner3 oi = new Outer3.Inner3();
		oi.show();
		//7.匿名的内部类对象调用show()
		new Outer3.Inner3().show();
		//9.访问静态内部类中的静态资源--链式加载
		Outer3.Inner3.show2();
	}
}
//1.创建外部类Outer3
class Outer3{
	//2.创建成员内部类Inner3
	//5.内部类被static修饰—并不常用!浪费内存!
	static class Inner3{
		//3.定义成员内部类中普通的成员方法
		public void show() {
			System.out.println("我是Inner3类的show()");
		}
		//8.定义成员内部类的静态成员方法
		static public void show2() {
			System.out.println("我是Inner3的show2()");
		}
	}
}

总结: 静态资源访问时不需要创建对象,可以通过类名直接访问 访问静态类中的静态资源可以通过”. . . ”链式加载的方式访问

5 局部内部类

创建包: cn.tedu.innerclass

创建类: TestInner4.java

package cn.tedu.innerclass;
/**本类用来测试局部内部类*/
public class TestInner4 {
	public static void main(String[] args) {
		/**如何使用内部类的资源呢?
		 * 注意:直接调用外部类的show()是无法触发内部类功能的
		 * 需要再外部类中创建内部类对象并且进行调用,才能触发内部类的功能
		 * */
		//5.创建外部类对象调用show()
		//7.当在外部类show()中创建局部内部类对象并且进行功能调用后,内部类的功能才能被调用
		new Outer4().show();
	}
}
//1.创建外部类Outer4
class Outer4{
	//2.创建外部类的成员方法
	public void show() {
		//3.创建局部内部类Inner4—不太常用!!!
		/**位置:局部内部类的位置在方法里*/
		class Inner4{
			//4.创建局部内部类的普通属性与方法
			String name;
			int age;
			public void eat() {
				System.out.println("我是Inner4的eat()");
			}
		}
		/**如何使用局部内部类的资源?*/
		//6.在show()里创建内部类对象
		Inner4 in = new Inner4();
		in.eat();
		System.out.println(in.name);
		System.out.println(in.age);
	}
}

6 匿名内部类

创建包: cn.tedu.innerclass

创建类: TestInner5.java

package cn.tedu.innerclass;
/*本类用于测试匿名内部类
* 匿名内部类没有名字,通常与匿名对象结合在一起使用*/
public class TestInner5 {
    public static void main(String[] args) {
        //传统方式:创建接口的实现类+实现类实现接口中的抽象方法+创建实现类对象+通过对象调用方法
        //3.创建接口一对应的匿名对象与匿名内部类,并调用实现了的方法save()
        new Inter1(){
            @Override
            public void save() {
                System.out.println("save()...");
            }
            @Override
            public void get() { }
        }.save();
        //5.创建抽象类对应的匿名对象与匿名内部类
        new Inter2(){
            @Override
            public void drink() {
                System.out.println("一人饮酒醉");
            }
        }.drink();
        //7.调用普通类的功能怎么调用?创建匿名对象直接调用
        new Inter3().powerUp();
        new Inter3().powerUp();//new了2次,所以是两个匿名对象
        /*如果想要多次使用实现后的功能,还是要创建普通的对象
        * 匿名对象只能使用一次,一次只能调用一个功能
        * 匿名内部类其实就充当了实现类的角色,去实现未实现的抽象方法,只是没有名字而已*/
        Inter3 in = new Inter3();
        in.study();
        in.study();
        in.study();
        in.study();
        in.study();
        in.study();
    }
}
//1.创建接口
interface Inter1{
    //2.定义接口中的抽象方法
    void save();
    void get();
}
//4.创建抽象类
abstract class Inter2{
    public void play(){
        System.out.println("Inter2...play()");
    }
    abstract public void drink();
}
//6.创建普通类
class Inter3{
    public void study(){
        System.out.println("什么都阻挡不了我想学习赚钱的决心");
    }
    public void powerUp(){
        System.out.println("我们会越来越强的!");
    }
}

总结: 匿名内部类属于局部内部类,而且是没有名字的局部内部类,通常和匿名对象一起使用

以上就是JAVA内部类示例详解及练习的详细内容,更多关于Java内部类的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java的内部类总结

    目录 前言 一,成员内部类 1,成员内部类的特点 2,成员内部类的实现 3,内部类和外部类的关系 二,静态内部类 1,静态内部类的特点 2,比较成员内部类和静态内部类 3,静态内部类的实现 三,方法内部类 1,方法内部类的特点 2,方法内部类的实现 四, 匿名内部类 1,匿名内部类的特点 2,匿名内部类的实现 总结 前言 最近看了内部类后,总结一下,首先内部类嵌套在其他内部的类,根据出现的位置和关键字,可以分为以下四种类:成员内部类,静态内部类,方法内部类,匿名内部类,接下来就介绍下这四种类,记

  • Java中的内部类你了解吗

    目录 成员内部类 1.定义 2.成员内部类的使用规则 3.成员内部类对象的创建: 4.内部类与静态域 静态内部类: 1.定义: 2.静态内部类的使用规则: 3.静态内部类对象的创建 成员内部类 VS 静态内部类 方法内部类: 1.定义: 2.方法内部类的使用规则: 3.注意形参的使用 匿名内部类(函数式编程) 总结 成员内部类 1.定义 成员内部类是直接定义在类中,不加任何修饰符的(特指不加static修饰的)的内部类,可以类比着成员变量来理解,如下面这个代码段中的Inn类就是一个成员内部类 p

  • 解析JavaSe的内部类

    目录 内部类 1.内部类简介 2.非静态内部类 3.静态内部类 4.匿名内部类 总结 内部类 1. 内部类简介 (1) 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类. (2) 内部类成员可以直接访问外部类的私有数据,因为内部类被当成其外部类成员,同一个类的成员之间可以互相访问.但外部类不能访问内部类的实现细节,例如内部类的成员变量. (3) 匿名内部类适合用于创建那些仅需要一次使用的类. (4) 在java中内部类主要分为成员内部类(非静态内部类.静态内

  • 学生视角带你了解Java内部类

    目录 一.内部类介绍 二.成员内部类: 1.非静态内部类 2.静态内部类 二.局部内部类: 2.有名的局部内部类 1.匿名局部内部类(重要) 一.内部类介绍 1.定义:一个类内部又嵌套了一个类,被嵌套的类就是内部类(inner class),嵌套其他类的称为外部类(outer class).内部类是类的五大成员之一(属性. 方法.构造器.代码块.内部类). 分类: 二.成员内部类: 1.非静态内部类 说明:定义在成员位置中(方法或代码块外面),无static修饰. 1.可以直接访问外部类的所有的

  • 详解Java匿名内部类

    匿名内部类: 先举个例子吧,给大家看一下什么是匿名内部类,Endeavor刚刚接触的时候,觉得哇哦,好奇怪的样子,这也太别扭了吧,不知道大家是什么感觉. 为了进行对比,先举一个正常的类方法调用的例子(大家应该都看的懂吧): 输出结果为: 接下来便开始说正题吧,匿名内部类,通过名字,想必大家就知道什么是匿名内部类了吧, 1.定义:就是没有名字的内部类(内部类之前介绍过了哦). 2.使用内部类有什么好处呢,一句话就概括了:简化书写,至于是怎么简化的,哪里简化了等下再说. 3.先说一下什么时候使用匿名

  • Java十分钟精通内部类的使用

    内部类: 其实内部类顾名思义,就是类中类,一个类里面还有一个类. 内部类分为四种: 普通内部类 静态内部类 方法内部类 匿名内部类 我们一一去了解一下~~ A.普通内部类: 我们先通过代码去了解一下: package InternalClass; /** * 内部类 */ public class Car { public int a = 10; public int b = 20; //外部类的方法 public void method() { System.out.println("我是外部

  • JAVA内部类示例详解及练习

    目录 1 内部类概述 2 特点 3 练习 : 内部类入门案例 4 成员内部类 4.1 练习 : 被private修饰 4.2 练习 : 被static修饰 5 局部内部类 6 匿名内部类 1 内部类概述 如果一个类存在的意义就是为指定的另一个类,可以把这个类放入另一个类的内部.就是把类定义在类的内部的情况就可以形成内部类的形式.A类中又定义了B类,B类就是内部类,B类可以当做A类的一个成员看待: 2 特点 1) 内部类可以直接访问外部类中的成员,包括私有成员 2) 外部类要访问内部类的成员,必须

  • java 内部类的详解及实例

     java 内部类的详解及实例 内部类的存在意义: 每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响.内部类使得多重继承的解决方案变得完整.接口解决了部分问题,二内部类有效地实现了"多重继承".(这是<Java编程思想>里面的解释) 代码: public class OuterAndInnerClass { public static void main(String[] args) { //创建内部类对象的

  • java教程之java继承示例详解

    什么是继承(extends)? 继承是:新定义的类是从已有的类中获取属性和方法的现象. 这个已有的类叫做父类, 从这个父类获取属性和方法的类叫做子类. ExtendsDemo1.java 复制代码 代码如下: /*什么是继承*/public class ExtendsDemo1 {    public static void main(String[] args) {        Truck t = new Truck();        t.size = 100;           //不

  • mongoDB中聚合函数java处理示例详解

    1.问题 最近在做项目的时候碰到一个对mongoDB的数据处理,从MongoDB中拿到内嵌文档的时间排序的list. 一开始考虑到直接对mongoDB中的属性排序,后面发现属性存在内嵌文档中,所以处理中需要用到聚合函数. 思考 (key)解决这个问题的过程让我学到很多,发现自己在解决一个问题不仅查找问题的姿势不对,浪费太多时间.而且在碰到问题之后,应该多看看解决办法,甚至解决了之后要去思考问题,回顾问题.而不是像以前一样,解决问题了就万事大吉,抛之脑后. 2.解决 需要对document中的一个

  • Java中LinkedList详解和使用示例_动力节点Java学院整理

    第1部分 LinkedList介绍 LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表.它也可以被当作堆栈.队列或双端队列进行操作. LinkedList 实现 List 接口,能对它进行队列操作. LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用. LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆. LinkedList 实现java.io.Serial

  • Java设计模式之单例模式示例详解

    目录 0.概述 1.饿汉式 1.1 饿汉式单例实现 1.2 破坏单例的几种情况 1.3 预防单例的破坏 2.枚举饿汉式 2.1 枚举单例实现 2.2 破坏单例 3.懒汉式 4.双检锁懒汉式 5.内部类懒汉式 6.JDK中单例的体现 0.概述 为什么要使用单例模式? 在我们的系统中,有一些对象其实我们只需要一个,比如说:线程池.缓存.对话框.注册表.日志对象.充当打印机.显卡等设备驱动程序的对象.事实上,这一类对象只能有一个实例,如果制造出多个实例就可能会导致一些问题的产生,比如:程序的行为异常.

  • Java基本语法之内部类示例详解

    目录 1.内部类概念及分类 2.实例内部类 2.1实例内部类的创建 2.2使用.this和.new 2.3内部类实现迭代打印 2.4内部类的继承 3.静态内部类 4.匿名内部类 1.内部类概念及分类 将一个类定义在另一个类的内部或者接口内部或者方法体内部,这个类就被称为内部类,我们不妨将内部类所在的类称为外围类,除了定义在类,接口,方法中的内部类,还有一种特殊的内部类,那就是使用关键字new创建一个匿名类的对象,而这个匿名类其实就是一个内部类,具体说是一个匿名内部类,经常用于传入构造器实参构造对

  • Java结构型设计模式中建造者模式示例详解

    目录 建造者模式 概述 角色 优缺点 应用场景 基本使用 创建产品类 创建建造者类 使用 链式写法 创建产品类与建造者类 使用 建造者模式 概述 建造者模式(Builder Pattern)属于创建型模式. 它是将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示. 简而言之:建造者模式就是使用多个简单的对象一步一步构建成一个复杂的对象. 建造者模式适用于创建对象需要很多步骤,但是步骤的顺序不一定固定.如果一个对象有非常复杂的内部结构(很多属性),可以将复杂对象的创建和使用进行分

  • java 与testng利用XML做数据源的数据驱动示例详解

    java 与testng利用XML做数据源的数据驱动示例详解 testng的功能很强大,利用@DataProvider可以做数据驱动,数据源文件可以是EXCEL,XML,YAML,甚至可以是TXT文本.在这以XML为例: 备注:@DataProvider的返回值类型只能是Object[][]与Iterator<Object>[] TestData.xml: <?xml version="1.0" encoding="UTF-8"?> <

  • Java逃逸分析详解及代码示例

    概念引入 我们都知道,Java 创建的对象都是被分配到堆内存上,但是事实并不是这么绝对,通过对Java对象分配的过程分析,可以知道有两个地方会导致Java中创建出来的对象并一定分别在所认为的堆上.这两个点分别是Java中的逃逸分析和TLAB(Thread Local Allocation Buffer)线程私有的缓存区. 基本概念介绍 逃逸分析,是一种可以有效减少Java程序中同步负载和内存堆分配压力的跨函数全局数据流分析算法.通过逃逸分析,Java Hotspot编译器能够分析出一个新的对象的

随机推荐