JAVA教程 从入门到精通 Day12

最新推荐文章于 2022-11-20 16:46:53 发布
最新推荐文章于 2022-11-20 16:46:53 发布
阅读量52 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dlogcs/article/details/123539346
版权

第五章 内部类

5.1 内部类

内部类 : 了解
类中定义类
外部类 内部类

分类:
    成员内部类
    私有内部类
    静态内部类
    局部内部类
    匿名内部类 : 重点
1、成员内部类

成员内部类

  • 内部类定义在外部类的成员位置
  • 具有类的特点 可以继承其他父类 实现其他接口
  • 具有成员的特点 可以被成员修饰符修饰

注意:

  • 成员内部类中不能定义静态内容 除了静态的常量
  • 成员内部类中可以直接使用外部类的成员 包括私有的
  • 外部类中可以通过成员内部类的对象调用成员内部类的成员
  • 通过外部类对象去创建成员内部类的对象 通过成员内部类对象调用成员内部类的成员
package wang;

public class Inner {
    //成员：类中方法外
    //成员变量
    private int i=1;
    static int j=2;

    //成员内部类
    public class Inner01{
//        成员变量
        int a=100;
        static final int b=200;

//        成员方法
        public void testInner01(){
            System.out.println(i);
            System.out.println(j);
            System.out.println(a);
            System.out.println(b);
        }
    }

//    成员方法
    public void outer(){
        Inner01 sc=new Inner01();
        System.out.println(sc.a);
    }
}

package wang;

//测试类
public class Over {
    public static void main(String[] args) {
//        测试使用成员内部类中的成员
        Inner sd=new Inner();
        Inner.Inner01 sf=sd.new Inner01();
        sf.testInner01();
    }
}
2、区分同名变量问题
package wang;
//区分同名变量问题
public class Inner {
        int i=1;
        static int b=5;

        class Inner01{
            int i=2;
            public void test(){
                int i=3;
//                调用外部类成员变量i=1
                System.out.println(Inner.this.i);
//                调用内部类的成员变量i=2
                System.out.println(this.i);
//                调用局部变量i
                System.out.println(i);
            }
        }
    }


package wang;

//测试类
public class Over {
    public static void main(String[] args) {
        Inner.Inner01 sc=new Inner().new Inner01();
        sc.test();
    }
}
3、私有内部类

私有内部类：

  • 被private关键字修饰的成员内部类
  • 私有内部类中可以直接使用外部类的成员,包括私有的
  • 在外部类中通过私有内部类的对象调用私有内部类的成员,包括私有的
  • 私有内部类只能在当前外部类中使用,其他类中无法使用
package wang;

public class Class004_Outer {
    private int i = 1;
    private static int j = 2;

    //私有内部类
    private class Inner{
        private int a = 100;
        private static final int b = 200;

        public void test(){
            System.out.println("私有内部类的成员方法");
            System.out.println(a);
            System.out.println(b);

            System.out.println(i);
            System.out.println(j);
        }
    }

    //外部类的成员方法
    public void outer(){
        Inner in = new Inner();
        System.out.println(in.a);
        in.test();
    }
}
4、静态内部类

静态内部类

  • 静态内部类中可以定义静态内容
  • 在静态内部类中可以直接使用外部类的静态内容 需要通过外部类对象使用外部类的成员
  • 在外部类中可以通过静态内部类的类名调用静态内部类的静态内容 可以通过静态内部类的对象调用其成员内容
  • 在其他类中可以通过外部类类名找到静态内部类 new 静态内部类对象访问其成员 通过静态内部类类名方法其静态内容
  • Class005_Outer.Inner in3 = new Class005_Outer.Inner();
public class Class005_Outer {
    private int i = 1;
    private static int j = 2;

    //静态内部类
    static class Inner{
        int a = 100;
        static int b = 200;

        //成员方法
        public void test(){
            System.out.println(b);
            System.out.println(a);

            System.out.println(j);
            System.out.println(new Class005_Outer().i);
        }

        //静态方法
        public static void testStatic(){
            Inner in = new Inner();
            System.out.println(in.a);

            System.out.println(b);

            System.out.println(new Class005_Outer().i);
            System.out.println(j);
        }
    }

    //外部类的成员方法
    public void outer(){
        System.out.println(Inner.b);
        Inner.testStatic();

        new Inner().test();
    }
}
5、局部内部类
  • 定义在局部位置
  • 局部内部类中可以定义成员内容 不可能定义静态内容除了静态的常量
  • 只能在局部内部类所在的方法中通过对象访问成员
  • 在局部内部类中可以使用所在方法中的局部变量 可以使用外部类的成员
  • 如果在局部内部类中使用所在方法中的局部变量(参数) 要求局部变量被final修饰 如果jdk1.8以上版本默认被final修饰
public class Class006_Outer {
    String str = "外部类str";
    public void test(int i){
        //局部
        //int i = 1;

        //局部内部类
        class Inner{
            int a = 100;
            static final int b = 200;

            public void testInner(){
                System.out.println("局部内部类的成员方法");
                System.out.println(i);
                System.out.println(str);
            }
        }

        //i = 6;
        System.out.println(Inner.b);
        Inner in = new Inner();
        System.out.println(in.a);
    }
}
6、匿名内部类

匿名内部类 :

  • 作用 : 简化实现类|子类,没有自己类本身作用的实现类|子类

匿名内部类对象 :

  • 实现类|子类+创建对象

​ new Smoke(){ //实现类类体|抽象类的子类类体

​ @Override

​ public void smoking() {

​ System.out.println(“边吸烟边吐烟圈…”);

​ }

​ }

public class Class007_Outer {
    public static void main(String[] args) {
        //实现类对象
        Demo demo = new Demo();
        demo.smoking();

        //匿名内部类对象
        //1. 匿名对象 : 只能在当前位置使用一次
        new Smoke(){ //实现类的类体 | 匿名内部类的类体
            @Override
            public void smoking() {
                System.out.println("一边打游戏一边吸烟...");
            }
        }.smoking();


        //2.引用指向匿名内部类对象
        //接口多态 : 接口引用调用的为接口中定义的成员
        Smoke s = new Smoke(){

            @Override
            public void smoking() {
                System.out.println("一边上课一边抽烟");
            }
        };
        s.smoking();
        s.smoking();
        s.smoking();

        //3.匿名内部类对象作为方法的实参
        test(new Smoke() {
            @Override
            public void smoking() {
                System.out.println("xxxxxxxx");
            }
        });
    }

    public static void  test(Smoke smoke){
        smoke.smoking();
    }

}

interface Smoke{
    void smoking();
}

class Demo  implements Smoke{
    @Override
    public void smoking() {
        System.out.println("边吸烟边吐烟圈...");
    }
}

5.2 Lambda 表达式

lambda表达式

作用 : 简化匿名内部类对象

前提 : 函数式接口

函数式接口 : 接口中只有一个必须被重写的抽象方法

强制检查是否为函数式接口 : @FunctionalInterface

语法 : ()->{}

  • () : 接口中抽象方法的参数列表
  • -> : lambda符号|箭头函数
  • {} : 重写方法的方法体
public class Class001_Lambda {
    public static void main(String[] args) {
        //匿名内部类
        /*Swim s = new Swim(){

            @Override
            public void swimming() {
                System.out.println("一边喝水一边游泳...");
            }
        };*/

        //Lambda写法1 : ()->{}
        /*Swim s = ()->{
            System.out.println("一边换气一边游泳...");
        };*/

        //Lambda写法2 : 如果方法体语句只有一句,前后的{}可以省略
        //Swim s = ()->System.out.println("一边嘻嘻笑一边游泳...");

        //Lambda写法3 : 如果方法存在参数,参数的类型可以省略
       // Swim s = (name,age)->System.out.println(name+"一边嘻嘻笑一边游泳...");

        //Lambda写法4 : 如果参数只有一个,前后的()可以省略
        //Swim s = name->System.out.println(name+"一边嘻嘻笑一边游泳...");

        //Lambda写法5 : 如果lambda体语句只有一句,并且为return语句,前后的{}与return关键字可以一起省略
        Swim s = age->age>18;

        System.out.println(s.swimming(18));;


    }
}

@FunctionalInterface
interface Swim{
    boolean swimming(int age);
    //void drinkWater();
}

interface Run{
    void run();
}
dlogcs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
接口 内部类
Liuxin2448的博客
01-19 696
接口 内部类什么是接口接口允许多重继承声明接口的语法接口中只能定义常量和抽象方法一个类实现接口的语法类实现接口接口中常量一个对象往往有多重身份接口的特殊特征接口的作用接口和抽象类的异同点内部类内部类的作用内部类相关的设计内部类分类非静态内部类静态内部类局部内部类匿名内部类匿名内部类的使用场景匿名内部类的使用限制内部类的使用场景和好处 什么是接口 在Java中不直接支持多继承,因为会出现调用的不确定性,所以Java将多继承机制进行改良,在Java中变成了多实现。一个类只能有一个直系双亲类,一个类可以实现多个接
java16天从入门到精通 畅购-讲师源码md课件.zip
02-26
本课程“Java 16天从入门到精通”旨在帮助初学者快速掌握Java编程的核心概念和技术。 【16天学习路线】 1. **Day 1：环境搭建** - 学习如何下载并安装Java Development Kit (JDK)，配置Java环境变量，以及使用Java...
四. 接口与内部类
weixin_39505091的博客
11-09 123
文章目录一. 接口二. 内部类 一. 接口 1. 引入 接口：用于描述类具有的功能，而不关心具体地实现。接口不是类，一个类可以实现一个或多个接口。接口中只允许声明方法和常量（不能定义域和方法的具体实现）。 如果一个类implements某个接口，就必须实现该接口中的所有方法。（抽象类允许不实现接口中的方法） 如Arrays.sort()可以对对象数组进行排序，但是要求对象所属类必须实现了Compa...
接口和内部类
weixin_52620731的博客
10-02 114
一.内部类 1.1.定义：  内部类简单来说就是在类的内部进行其他定义的操作 举个例子： public class Inner_class { public static void main(String[] args) { outer out = new outer(); out.println2(); } } class outer{ public String str1 = "定义的外部类"; class inner{ p
第6章 接口,内部类
静妮子的博客
11-18 258
第6章 接口,lambda表达式与内部类接口定义接口：实现接口：接口属性：接口与抽象类的区别：默认方法接口与回调对象克隆内部类 接口 Java中，接口不是类，而是对希望符合这个接口的类的一组需求。用于描述类具有什么功能，而不用给出每个功能的具体实现。 接口中： 方法——隐含为public abstract 变量——隐含为public static final 定义接口： [public] interface 接口名[extends 接口列表] { 返回类型 方法名（）；不能更改 常量类型 常量名=…；不
Java 中的内部类
林二月的博客
07-09 1375
本文详细解释了 内部类 的概念与使用，并深入介绍了 4种内部类 的注意事项和细节。这一部分的知识非常的多且琐碎，而且想要理解好需要较好的面向对象的基础。小白博主已经尽力整理了，希望小伙伴们看后能有所收获！最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！
JavaSE基础入门视频教程33天之（22） part3
09-09
本视频教程“JavaSE基础入门视频教程33天之（22） part3”旨在帮助初学者快速掌握这些基础知识，并通过实际操作提升编程技能。 在这一部分中，重点讲解了IO流对象及其在递归操作中的应用。IO流在Java中扮演着至关...
JavaSE基础入门视频教程33天之（21） part1
09-09
在这个33天的系列视频教程中，第21天主要探讨的是Java中的异常处理，这对于任何Java开发者来说都是至关重要的技能。异常处理是程序在遇到错误或不可预见情况时的一种机制，它确保了程序的稳定性和健壮性。 首先，...
JavaSE基础入门视频教程33天之（23） part2
09-09
JavaSE基础入门是Java编程学习的第一步，这个33天的视频教程系列旨在帮助初学者逐步掌握Java的核心概念。在第23部分中，我们主要聚焦于IO流，这是一个非常关键且实用的主题，尤其对于处理文件操作至关重要。IO流允许...
贺岁大数据入门spark3.0入门Spark-day07.rar
02-21
2021贺岁大数据入门spark3.0入门到精通资源简介： 本课程中使用官方在2020年9月8日发布的Spark3.0系列最新稳定版：Spark3.0.1。共课程包含9个章节：Spark环境搭建，SparkCore，SparkStreaming，SparkSQL，...
【JavaSE】接口
最新发布
Autonmy_的博客
11-20 677
1.定义方法接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。//成员变量 //成员方法 }创建接口时, 接口的命名一般以大写字母 I 开头.接口的命名一般使用 “形容词” 词性的单词.2.接口中的成员方法，只能是抽象方法(被default修饰及静态方法除外)，所以的方法 都默认是 public abstract//固定为这个 public void method2();}
java中的内部类内部接口详解
程序那些事
05-08 1万+
文章目录简介内部类静态内部类非静态内部类静态方法内部类非静态方法的内部类匿名类内部接口总结 简介 一般来说，我们创建类和接口的时候都是一个类一个文件，一个接口一个文件，但有时候为了方便或者某些特殊的原因，java并不介意在一个文件中写多个类和多个接口，这就有了我们今天要讲的内部类和内部接口。 内部类 先讲内部类，内部类就是在类中定义的类。类中的类可以看做是类的一个属性，一个属性可以是static也...
【JavaSE】内部类超详细解析
weixin_45720193的博客
09-23 253
在一个类（外部类）中将另一个类（内部类）当做其的私有成员。
Java的接口和内部类
salary的专栏
09-20 2259
在学习Android事件机制之前，有必要把相关的Java知识先进行一下回顾。与Android事件相关的Java知识主要包括：接口、内部类，下面讲解这些知识点。 1、接口 Java下接口主要描述类应该具备什么功能。接口是一种契约机制，描述了相关的类应遵循一定的、统一的格式定义。在Java中，接口通过关键字Interface定义。例如下面的接口定义： package com.zhangw...
java 内部接口 内部类_Java接口/内部类
weixin_33292780的博客
02-12 176
抽象方法我先举个例子引出抽象方法，例如求圆、矩形、三角形、这些图形的面积????发现的问题每一个图形计算面积的方式都不一样, 所以每一个类都必须得要覆盖父类当中的getArea方法, 来去实现不同图形求面积的方式????带来的问题怎么样保证子类必须得要覆盖父类当中定义的方法父类不需要提供方法体抽象方法定义格式：在方法前面添加了一个关键字abstract????抽象方法的特点抽象方法是没有方法体的抽象方法必须得要定义...
java 内部接口 内部类_java 四种内部类和内部接口
weixin_34524392的博客
02-12 234
/*** 常规内部类：常规内部类没有用static修饰且定义在在外部类类体中。* 1.常规内部类中的方法可以直接使用外部类的实例变量和实例方法。* 2.在常规内部类中可以直接用内部类创建对象*/public class MyOuter {private int x = 100;class MyInner{private String y="Hello!";public void innerMeth...
java语言之jdk1.8的新特性
weixin_44771551的博客
09-08 155
jdk1.8新特性 一、Lambda表达式 （1）概念 Lambda表达式是特殊的匿名内部类，语法更简洁。 Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。 （2）语法 函数式接口 变量名 = (参数1，参数2…) -> { //方法体 }; Lambda引入了新的操作符：->(箭头操作符)，->将表达式分成两部分： 左侧：(参数1，参数2…)表示参数列表 右侧：{ }内部是方法体 （3）使用 //匿名内部类 Runnable
java 匿名内部类
热门推荐
zhbi98 的技术 Blogs
04-10 1万+
1. 匿名内部类介绍 使用 Java 编程时，常常需要创建不会被再次使用的对象。在这种情况下，非常适合使用一种特殊 的内部类：匿名内部类。这种类没有名称，是在同一条语句中声明和创建的。 要使用匿名内部类，可将引用对象的代码替换为关键字 new、对构造函数的调用以及用大括号 （{和}）括起的类定义。 既然是匿名类，所以你无法在别的地方实例化和使用这个类。 匿名内部类也可用于接口（interface）的实现 特点 匿名对象：没有名字的对象。 new ClassName().run(); 非匿名对象：含有名
校企合作(慧与(惠普)-国际软件人才基地)企业实训——Java抽象类和接口
qq_43047852的博客
08-13 224
* 抽象类： * 1.什么是抽象类？ * 如果一个类表达的是一种抽象的概念，仅仅作为其他派生类的一个父类，主要功能的定义，具体的实现交给 * 他的子类来做 * 2.语法 * 在class前面加上abstract就是一个抽象类 * * 3.抽象类的特点： * (1).抽象方法所在的类必须是抽象类 * (2).抽象类不能进行实例化 * (3).如果要实现一个抽象类，创建一个子类去继承这个抽象类 * (4).子类继承抽象类以后，必须重写抽象类里面所有的抽象方法(前提子类不是抽象类) * ...
Introduction to SQL (1).ppt
10-27
Sailors关系可能包含水手的ID（sid）、姓名（sname）和评分（rating），而Reserves关系可能表示预订信息，包括水手ID（sid）、船只ID（bid）和日期（day）。作者指出，如果Reserves的关系键仅包含sid和bid，其语义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值