内部类

最新推荐文章于 2022-02-25 22:31:36 发布
最新推荐文章于 2022-02-25 22:31:36 发布
阅读量116 收藏
点赞数
文章标签： 多态 类 class java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42832437/article/details/106359556
版权
1.内部类的概念与分类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一 个类。
例如:身体和心脏的关系。又如:汽车和发动机的关系。
分类:

  1. 成员内部类
  2. 局部内部类(包含匿名内部类)
2.成员内部类
2.1成员内部类的定义
成员内部类的定义格式:
修饰符class 外部类名称{
修饰符class 内部类名称{
// ...
}
// ...
}
注意:内用外，随意访问;外用内，需要内部类对象。
package cn.itcast.day10.demo05;

public class Body { //外部类
   public class Heart{  //成员内部类
       //内部类的方法
       public void beat(){
           System.out.println("小鹿乱撞");
       }
   }
    //外部类的成员变量
    private String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
2.2成员内部类的使用

如何使用成员内部类——有两种方式:

  1. 间接方式:在外部类的方法当中，使用内部类;然后main只是调用外部类的方法。
  2. 直接方式，公式: 外部类名称.内部类名称对象名= new外部类名称(). new内部类名称();
package cn.itcast.day10.demo05;

public class Body { //外部类
   public class Heart{  //成员内部类
       //内部类的方法
       public void beat(){
           System.out.println("小鹿乱撞");
           System.out.println("我是内部类的方法");
       }
   }
    //外部类的成员变量
    private String name;

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

    public String getName() {
        return name;
    }

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

package cn.itcast.day10.demo05;

public class InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();
        System.out.println("=================");
        Body.Heart body1 = new Body().new Heart();
        body1.beat();

    }

}

执行结果

外部类的方法
小鹿乱撞
我是内部类的方法
=================
小鹿乱撞
我是内部类的方法
2.3内部类的同名变量访问

如果出现了重名现象，那么格式是:外部类名称. this .外部类成员变量名。

package cn.itcast.day10.demo05;

public class Outer {
    int num = 10;   //外部类的成员变量
    public class Inner{
        int num = 20; //内部类的成员变量
        public void methodInner(){
            int num = 30;  //内部类方法的局部变量
            System.out.println(num); //局部变量，就近原则
            System.out.println(this.num); //内部类的成员变量
            System.out.println(Outer.this.num);  //外部类的成员变量

        }
    }
}

主函数

package cn.itcast.day10.demo05;

public class InnerClass02 {
    public static void main(String[] args) {
        Outer.Inner a = new Outer().new Inner();
        a.methodInner();
    }
}

执行结果

30
20
10
3.局部内部类
3.1 局部内部类的定义
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式: 
修饰符class 外部类名称{
修饰符返回值类型外部类方法名称(参数列表) {
class
局部内部类名称{
// ...
}
}

局部内部类

package cn.itcast.day10.demo05;

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

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

主函数

package cn.itcast.day10.demo05;

public class InnerClass03 {
    public static void main(String[] args) {
             Outer03 obj = new Outer03();
             obj.methodOuter();
    }
}

执行结果

10

小结一下类的权限修饰符:
public > protected > (default) > private
定义一个类的时候，权限修饰符规则:

  1. 外部类: public / (default)
  2. 成员内部类: public / protected / (default) / private
  3. 局部内部类:什么都不能写
3.2匿名内部类

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

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

接口

package cn.itcast.day10.demo06;

public interface MyInterface {
    void method();
}

主函数

package cn.itcast.day10.demo06;

public class MyInterfaceNou {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类执行了");
            }
        };
        obj.method();
    }
}

执行结果

匿名内部类执行了

匿名内部类的注意事项
对格式“new接口名称() {…}"进行解析:

  1. new代表创建对象的动作
  2. 接口名称就是匿名內部类需要实现哪个接口
  3. {… }这才是匿名内部类的内容

另外还要注意几点问题:

  1. 匿名内部类，在[创建对象]的时候，只能使用唯一一次 。如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
  2. 匿名对象，在[调用方法]的时候，只能调用唯一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  3. 匿名内部类是省略了[实现类/子类名称]，但是匿名对象是省略了[对象名称]
    强调:匿名内部类和匿名对象不是一回事! ! !

接口

package cn.itcast.day10.demo06;

public interface MyInterface {
    void methodA();
    void methodB();
}

主函数

package cn.itcast.day10.demo06;

public class MyInterfaceNou {
    public static void main(String[] args) {
        //使用匿名内部类，但不是匿名对象，对象名称就叫obj
        MyInterface obj = new MyInterface() {
            @Override
            public void methodA() {
                System.out.println("匿名内部类执行了---AAA");
            }
            public void methodB() {
                System.out.println("匿名内部类执行了---BBB");
            }
        };
        obj.methodA();
        obj.methodB();
        System.out.println("=============");

        //使用了匿名内部类，而且省略了对象名称，也是匿名对象

        new MyInterface() {
            @Override
            public void methodA() {
                System.out.println("匿名内部类执行了---CCC");
            }
            public void methodB() {
                System.out.println("匿名内部类执行了---DDD");
            }
        }.methodA();
        //因为匿名对象无法调用第二次方法，所以需要再创建一 个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void methodA() {
                System.out.println("匿名内部类执行了---CCC");
            }
            public void methodB() {
                System.out.println("匿名内部类执行了---DDD");
            }
        }.methodB();
    }
}

执行结果

匿名内部类执行了---AAA
匿名内部类执行了---BBB
=============
匿名内部类执行了---CCC
匿名内部类执行了---DDD
4.类作为成员变量类型

思路：创建一个英雄类，自己写一个武器类，然后加入到英雄类里面，类似一个成员变量。
武器类

package cn.itcast.day10.demo07;

public class Weapon {
    private String weaponName;

    public Weapon() {
    }

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

    public String getWeaponName() {
        return weaponName;
    }

    public void setWeaponName(String weaponName) {
        this.weaponName = weaponName;
    }
}

英雄类

package cn.itcast.day10.demo07;

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.getWeaponName() + "攻击敌方");
    }

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

主函数

package cn.itcast.day10.demo07;

public class HeroMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("亚瑟");
        hero.setAge(19);

        //创建一个武器对象
        Weapon weapon = new Weapon("极影之狼");
        hero.setWeapon(weapon);
        hero.attack();
    }

}

执行结果

年龄为19的亚瑟用极影之狼攻击敌方
5.接口作为成员变量类型

思路：在英雄类里面添加一个技能，技能用接口完成，相当于接口作为成员变量类型。
技能接口

package cn.itcast.day10.demo08;

public interface Skill {
    void use();//释放技能的抽象方法
}

英雄类

package cn.itcast.day10.demo08;

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

主函数

package cn.itcast.day10.demo08;

public class SkillMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("露娜");
        //匿名内部类实现
        Skill skill = new Skill() {
            @Override
            public void use() {
                System.out.println("月下无限连");
            }
        };
        hero.setSkill(skill);
        hero.attack();
        System.out.println("============================");

       //使用匿名内部类和匿名对象
        Hero hero2 = new Hero();
        hero2.setName("艾伦");
        hero2.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("寒冰之剑");
            }
        });
        hero2.attack();

    }
}

执行结果

露娜开始释放技能
月下无限连
释放技能完成
============================
艾伦开始释放技能
寒冰之剑
释放技能完成
6.接口作为方法的参数和返回值
package cn.itcast.day10.demo08;
import java.util.ArrayList;
import java.util.List;
//java.util.List正是ArrayList所实现的接口

public class DemoInterface {
    public static void main(String[] args) {
        //左边是接口名称，右边是实现类名称,这就是多态写法
        List<String> list = new ArrayList<>();
        List<String> res = addNames(list);
        
        for (int i = 0; i < res.size(); i++) {
            System.out.println(res.get(i));
        }
        }
        
    public static List<String> addNames(List<String> list){
        list.add("乔丹");
        list.add("科比");
        list.add("詹姆斯");
        list.add("韦德");
        return list;
    }
}
孤鸿末子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
内部类-----
weixin_69772191的博客
07-03 307
内容有借鉴其他软件
第6节课总结类的继承~学渣被代码虐啊虐的，就习惯了~~
u011324981的专栏
07-14 94
一、继承的语法格式 public class 类名(子类名，超类名，派生类名) extends （ 父类、基类）{ } **Java的单继承性，只有一个直系子类 **如果父类中存在一个构造方法，则子类中必须存在一个跟他 相同的构造方法 二、能够继承与能够调用的区别 1、子类可以继承到父类的所有属性和方法 2、但是由于访问修饰符的问题，导致只有一部分属性和方法 能被子...
我的 java 入门进阶之路 （七）
Specif1c的博客
07-06 299
一、final关键字 1.1 概述： 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。 final ： 不可改变。可以用于修饰类、方法和变量。 类：被修饰的类，不能被继承。 方法：被修饰的方法，不能被重写。 变量：被修饰的变量，不能被重新赋值。 1.2 使用方式： 修饰类： 格式如下： final class
Java 中public static void main(String []args){}的含义
Don't rush and never settle. If it's meant to be, it will be.
10-11 2867
图解： 很直观的，这个public static void main(String[]args){}包括：public：为什么是public，因为如果定义为私有private则外界无法访问此方法，故是public。static：为什么是static，因为JVM要调用这个方法，static可以保证此方法一直在内存中，故是static。void：为什么是void,因为main方法不需要返回值，故是vo
JAVA常用类与内部类
12-22
什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，属于类的成员，创建成员内部类对象必须依赖外部类对象。 2、静态内部类：定义在类中的类，class 关键字前...
Java的内部类和匿名类剖析
01-21
在那些修改中，引人注目的是内部类和匿名类。如运用得当，它们可使程序更易理解和维护。本文介绍内部类和匿名类在Java代码中是如何具体工作的，如何正确使用它们，以及如何避免一些常见的错误。 下面来看看这些特性...
详细分析内部类的发生内存泄漏的原因
01-20
文章目录避免内部类中的内存泄漏步骤1：内部类引用其外部类步骤2：构造函数获取封闭的类引用步骤3：声明一种新方法内存泄漏的解剖 避免内部类中的内存泄漏 使用内部类时要当心垃圾收集 如果您已了解静态类和内部类，...
Java中的静态内部类详解及代码示例
08-29
Java中的内部类主要分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。 成员内部类是最普通的内部类，它是一个普通的类定义在另一个类的内部。成员内部类可以直接访问外部类的属性和方法，即使是private...
Java局部内部类和匿名内部类定义与用法实例分析
08-25
"Java 局部内部类和匿名内部类定义与用法实例分析" Java 局部内部类和匿名内部类是 Java 编程语言中两种重要的内部类定义方式，它们在 Java 面向对象程序设计中扮演着重要的角色。本文将详细介绍 Java 局部内部类和...
7. 吴恩达机器学习课程-作业7-Kmeans and PCA
wujing1_1的博客
02-22 1037
fork了别人的项目，自己重新填写，我的代码如下 https://gitee.com/fakerlove/machine-learning/tree/master/code 代码原链接 文章目录7. 吴恩达机器学习课程-作业7-Kmeans and PCA7.1 k-means7.1.1 题目介绍7.1.2 算法流程7.1.3 实现k-means7.1.4 测试7.2 图像压缩与k-均值7.3 PCA7.3.1 题目介绍7.3.2 算法流程7.3.3 代码1) 示例数据集2) 实现PCA3) 脸图像数据集
算法提高分类学习刷题——1.动态规划——1.3背包模型
m0_51474171的博客
02-25 3466
（1）01背包 模型 题目介绍 有 N件物品和一个容量为 V 的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。 「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。 动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i个物品的做出决策，「0-1」正好代表不选与选两种决定。 二维 （1）状态f[i][j]定义：前i个物品，背包容量j下的最优解（最大价值）： 当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开.
算法提高分类学习刷题——1.动态规划——1.2.最长上升子序列模型
m0_51474171的博客
02-21 1433
最长上升子序列模型 1.最长上升子序列 题目描述 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤1000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 解题思路 因为以i结尾的子序列，一定是由前i-1个数结尾的子序列长度加一取max 比如一个子序列a[j]a[i] ,那么当a[j]<a[i
类和对象进阶
sqjddb的博客
02-23 503
/关于访问限定符的几点说明 /类的实例化 /计算类对象的大小 /深入理解this指针 /六大默认成员函数 /const修饰成员函数 /细谈成员函数 /对象成员的初始化 /static成员 /友元 /内部类
经典的图像分类模型
最白の白菜的博客
02-22 5279
目录经典的图像分类模型AlexNetAlexNet的网络架构手写数字势识别数据读取模型编译模型训练模型评估VGGVGG的网络架构手写数字势识别数据读取模型编译模型训练模型评估GoogLeNetInception 块GoogLeNet模型B1模块B2模块B3模块B4模块B5模块手写数字识别数据读取模型编译模型训练模型评估延伸版本InceptionV2InceptionV3ResNet残差块ResNet模型手写数字势识别数据读取模型编译模型训练模型评估 经典的图像分类模型 AlexNet 学习目标 知道Ale
年薪20W的自动化测试工程师教你用Postman做接口测试
02-23 2015
The higher your test coverage, the more flexible and bug-resistant your code will be, and the less time you’ll spend debugging hot fixes in production. 测试覆盖率越高，代码就越灵活，生产中调试修补程序所花费的时间就越少。 首先，比较遗憾的一点是，Postman对并发测试并不好，但支持指定次数与间隔时间的串行测试。 官方文档链接：Postman .
图像分类入门
最白の白菜的博客
02-21 3024
图像分类入门 学习目标 知道图像分类的目的 知道imageNet数据集 图像分类 图像分类实质上就是从给定的类别集合中为图像分配对应标签的任务。也就是说我们的任务是分析一个输入图像并返回一个该图像类别的标签。 假定类别集为categories = {dog, cat, panda}，之后我们提供一张图片给分类模型，如下图所示： 分类模型给图像分配多个标签，每个标签的概率值不同，如dog:95%，cat:4%，panda:1%，根据概率值的大小将该图片分类为dog，那就完成了图像分类的任务。 常用数据集
机器学习 聚类算法总结
qq_50909707的博客
02-23 2002
一、聚类算法简述 二、K-Means算法实现案例一——简单实现 # 一、导入库 import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import MiniBatchKMeans, KMeans from sklearn import metrics from sklearn.datasets._samples_generator import make_blobs def handler(): ...
EasyRecovery15专业电脑数据恢复黑科技软件
CaiHuaZeiPoJie的博客
02-25 5657
EasyRecovery15专业电脑数据恢复黑科技软件
Java内部类深入解析
内部类分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。成员内部类是定义在类的成员位置的类，就像字段一样。在提供的代码示例中，`Contents` 就是一个成员内部类，它被定义在 `First` 类的内部。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值