Java笔记之面向对象 下（十四）

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量169 收藏
点赞数
分类专栏： 自学Java 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44604159/article/details/124484828
版权

学习目录

一.内部类☆

1.基本介绍

一个类的内部完整的嵌套了另一个类结构，则被嵌套的类称为内部类，而嵌套内部类的类称为外部类

类的五大成员：属性、方法、构造器、代码块、内部类

内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类直接的关系

语法格式
class 类名{ //外部类
　class 类名{ //内部类
　}
}

内部类的分类

  1. 定义在外部类局部位置上（如：方法内部）
    ①局部内部类（有类名）
    ②匿名内部类（没有类名）☆
  2. 定义在外部类的成员位置上
    ①成员内部类（没有static修饰）
    ②静态内部类（有static修饰）
class A{
    class B{ }  //成员内部类
    static class C{ }  //静态内部类

    public void test(){
        class D{ }  //局部内部类
        new p1(){};    //匿名内部类（类）
        new p2(){};    //匿名内部类（接口）
    }
}

class p1{}	
interface p2{}

2.局部内部类

局部内部类是定义在外部类的局部位置，比如方法、代码块，且有类名

语法格式

class 外部类名{
　public void 方法名(){
　　class 内部类名{ }
　}
}

使用细节

  1. 可以直接访问外部类的所有成员包括私有
  2. 不能添加访问修饰符，因为它是一个局部变量，局部变量是不能使用修饰符的，但可以使用final
  3. 内部类的作用域仅仅只在它所在的方法中或代码块中
  4. 外部类访问内部类成员，直接创建外部类对象，调用内部类所在的方法或代码块
  5. 局部内部类只能被方法内部访问（因为局部内部类的本质是一个局部变量）
  6. 如果外部类和局部内部类的成员(属性或方法等)重名时，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问
public class test1 {
    public static void main(String[] args) {
        //细节四
        A a = new A();
        a.test2();  //方法test2中的内部类a的值=20

        //细节五
//        new B();    //其他类不能访问局部内部类

        //细节六
        a.test3();
    }
}

class A{
    private int a = 1;
    private void p(){
        System.out.println("外部类的方法");
    }

    public void test(){
        class B{
            //细节一
            public void s(){
                System.out.println(a);
                p();
            }
        }

        //细节二
//        public class B1{}   //错误
        final class B1{}    //正确
    }

    //细节三
    public void test1(){
        class B2{ }
        B2 b2 = new B2();   //正确
    }
//    B2 b2 = new B2();   //错误

    //细节四
    public void test2(){
        class B3{ int b = 20; }
        B3 b2 = new B3();   //正确
        System.out.println("方法test2中的内部类a的值="+b2.b);
    }

    //细节五
//    new B();  //错误

    //细节六
    public void test3(){
        class B4{
            int a = 10;  //与外部类属性重名，遵守就近原则
            public void f(){
                System.out.println("内部类属性a="+a); //10
                //如果想在内部类访问外部类的属性则 外部类名.this.属性名
                System.out.println("外部类属性a="+A.this.a);
            }
        }

        B4 b4 = new B4();
        b4.f();
    }
}

3.匿名内部类☆☆☆

匿名内部类本质是内部类，该类没有名字，同时还是一个对象（在源码中和一些框架中经常用到）

说明：匿名内部类是定义在外部类的局部位置 如：方法中

语法格式：
class 类名{ //外部类
　public void 方法名(){
　　new 类或接口(参数列表){ } //匿名内部类
　}
}

使用场景

有时候有的内部类只需要创建一个它的对象就可以了,以后再不会用到这个类,这时候使用匿名内部类就比较合适,而且也免去了给它取名字的烦恼

也就是说当某一个对象只想使用一次时可以用匿名内部类，可以简化开发

快速入门

getClass()获取对象的运行类型

public class test1 {
    public static void main(String[] args) {
        demo demo = new demo();
        demo.p();
        //test...
        //Anonymous的匿名内部类的运行类型=class com.test.demo$1
        //name=张三
        //Anonymous1的匿名内部类的运行类型=class com.test.demo$2
    }
}

class demo{
    public void p(){
        //把这个匿名内部类赋值给A接口类型Anonymous
        //匿名内部类在赋值给你Anonymous以后，这个匿名内部类就不存在了，不能用了，因为只能使用一次
        /*
        分析：
        1.Anonymous的编译类型=A
        2.Anonymous的运行类型=demo$1
        3.其实底层代码就会创建匿名内部类
        class demo$1 extends A{
            @Override
            public void test() {
                System.out.println("test...");
            }
        }
         */
        A Anonymous = new A() {
            @Override
            public void test() {
                System.out.println("test...");
            }
        };
        Anonymous.test();   //调用匿名内部类的方法
        System.out.println("Anonymous的匿名内部类的运行类型="+Anonymous.getClass());

        /*
        分析：
        1.Anonymous1的编译类型=B
        2.Anonymous1的运行类型=demo$2
        3.其实底层代码就会创建匿名内部类
        class demo$2 extends B{ }
        4.参数列表会传给 构造器
         */
        B Anonymous1 = new B("张三"){
        };
        System.out.println("Anonymous1的匿名内部类的运行类型="+Anonymous1.getClass()); //getClass()获取对象的运行类型

    }
}

interface A{
    void test();
}

class B{
    String name;
    public B(String name) {
        System.out.println("name="+name);
    }
    public void test(){ };
}

使用细节

  1. 匿名内部类既是一个类的定义，也是一个对象，所以它既有定义类的特征，也有创建对象的特征
  2. 可以直接访问外部类的所有成员，包括私有
  3. 不能添加访问修饰符，因为它是一个局部变量
  4. 作用域只能在定义它的方法或代码块中
  5. 外部其他类不能访问匿名内部类成员，因为他是一个局部变量
  6. 如果外部类和匿名内部类的成员(属性或方法等)重名时，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问
public class test1 {
    public static void main(String[] args) {
        demo demo = new demo();
        demo.p();
        System.out.println("============");
        demo.p1();

    }
}

class demo{
    private int a = 1;
    private void demo1(){
        System.out.println("外部类的方法！");
    }

    public void p1(){
        //细节2
        A b = new A() {
            @Override
            public void test() {
                System.out.println("外部类属性a=" + a);  //外部类属性
                demo1();    //外部类方法
            }
        };
        b.test();
    }

    public void p(){
        //细节1，当匿名内部类是一个类的定义
        A a = new A() {
            @Override
            public void test() {
                System.out.println("匿名内部类是一个类的定义的test方法！");
            }
        };
        a.test();   //动态绑定，运行类型则是demo$1
        //细节1，当匿名内部类是一个对象
        new A() {
            @Override
            public void test() {
                System.out.println("匿名内部类是一个对象的test方法！");
            }
        }.test();   //也可以直接调用，匿名内部类本身也是返回对象


        //细节6,如果匿名内部类属性与外部类属性重名时
        new A() {
            int a = 20;
            @Override
            public void test() {
                System.out.println("匿名内部类属性a="+a);  //就近原则 a=20
                System.out.println("外部类属性a="+demo.this.a);  //a=1
            }
        }.test();
    }
}

class A{
    public void test(){
        System.out.println("A类的test方法！");
    };
}

最佳实践

把匿名内部类当作实参直接传递，简洁高效

public class test1 {
    public static void main(String[] args) {
        //匿名内部类的方式，
        Person person = new Person();
        person.exercise(new motion() {
            @Override
            public void method() {
                System.out.println("匿名内部类：跑步中...");
            }
        });
        person.exercise(new motion() {
            @Override
            public void method() {
                System.out.println("匿名内部类：跳绳中...");
            }
        });


        //普通方法-硬代码的方式
        Person1 person1 = new Person1();
        person1.method();
        Person2 person2 = new Person2();
        person2.method();


    }
}

interface motion{
    void method();
}
class Person{
    public void exercise(motion motion){    //接口类型
        motion.method();
    }
}

class Person1 implements motion{
    @Override
    public void method() {
        System.out.println("普通方法：跑步中！！！");
    }
}

class Person2 implements motion{
    @Override
    public void method() {
        System.out.println("普通方法：跳绳中！！！");
    }
}

4.成员内部类

语法格式
class 外部类名{
　class 成员类名{
　}
}

使用细节

  1. 可以直接访问外部类成员，包括私有的
  2. 可以添加访问修饰符（public、protected、默认、private），因为它就是外部类的一个成员
  3. 作用域跟外部类的其它成员一样，为整个类体
  4. 外部类访问成员内部类 访问方式：先创建对象，再访问
  5. 如果外部类和成员内部类的成员(属性或方法等)重名时，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.this.成员）去访问
public class test1 {
    public static void main(String[] args) {
        A a = new A();
        a.test();
    }
}
class A{
    private int a = 1;

    //细节二
    public class B{
        int a = 20;
        //细节一
        public void say(){
            System.out.println("a="+a);
            //细节五
            System.out.println("成员内部类a="+a);
            System.out.println("外部类成员a="+A.this.a);
        }

    }

    public void test(){
        //细节四 使用成员内部类
        B b = new B();
        b.say();
    };
}

5.静态内部类

语法格式
class 外部类名{
　static class 成员类名{
　}
}

使用细节

  1. 可以直接访问外部类的所有静态成员，包含私有的（注意：不能访问非静态成员）
  2. 可以添加访问修饰符（public、protected、默认、private），因为它就是外部类的一个成员
  3. 作用域跟外部类的其它成员一样，为整个类体
  4. 外部其他类使用静态内部类，可以通过类名直接访问，前提满足访问权限
  5. 外部类访问静态内部类访问方式：
    方法一：先创建对象，再访问
    方法二：编写一个方法返回静态内部类的对象实例，再访问
    方法三：编写一个静态方法返回静态内部类的对象实例，再访问
  6. 如果外部类和静态内部类的成员(属性或方法等)重名时，默认遵循就近原则，如果想访问外部类成员，则可以使用（外部类名.成员）去访问
public class test1 {
    public static void main(String[] args) {
        //细节四 方法一
        System.out.println("细节四 方法一");
        A.B b = new A.B();
        b.say();

        //细节四 方法二
        System.out.println("细节四 方法二");
        A a = new A();
        A.B b1 = a.getB();
        b1.say();

        //细节四 方法三
        System.out.println("细节四 方法三");
        A.B b11 = A.getB1();
        b11.say();
    }
}
class A{
    private int a = 1;
    private static int b = 1;

    //细节二
    public static class B{
        int b = 20;

        //细节一
        public void say(){
//            System.out.println(a);//错误,必须是静态成员
            System.out.println("成员静态属性b="+b);

            //细节五
            System.out.println("静态内部类b="+b);
            System.out.println("外部类成员b="+A.b);
        }
    }

    //细节四 方法一
    public void test(){
        B b = new B();
        b.say();
    };
    //细节四 方法二
    public B getB(){
        return new B();
    }

    //细节四 方法三
    public static B getB1(){
        return new B();
    }
}
王博1999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java学习笔记之面向对象基本概念
12-22
　面向对象程序设计是将人们认识世界过程中普遍采用的思维方法应用到程序设计中。 　对象是现实世界中存在的事物，它们是有形的，如某个人、某种物品;也可以是无形的，如某项计划、某次商业交易。 　对象是构成...
【vs C++】error LNK2019: 无法解析的外部符号 "public: void __thiscall
u013321328的专栏
03-20 3637
1 很多编译器显示错误，并不是本行，而是上一行的错误(看出错前后几行一般能找到问题) 2 一般报一堆错误，找第一个错误改了再编 Log 出现这个错误，应该首先查看“#include”语句是否包含，或者是否包含正确。符号无法解析意味着编译器知道有这个符号存在，也就是有声明，但在链接时，找不到实现代码，那么就去看看报错的这个函数有没有实现代码。如果它们的确已经有了，还是出现这个错误，就把它们重...
public void与public static void区别
热门推荐
qq_41867256的博客
02-26 1万+
public void定义的是普通的方法，而public static void 定义的是静态的方法。 普通的方法需要new对象去调用，而静态的方法可以直接用类名去调用。
public 方法名()与public void 方法名()与public static void 方法名()区别
qq_54154945的博客
01-20 1万+
1.public 方法名(). 构造函数，与类名一样。不能带返回类型。若是在一个类中定义的，则该方法必须在实例化该类的对象后才能调用 2.public void 方法名(). 类的成员函数。若是在一个类中定义的，则该方法必须在实例化该类的对象后才能调用 调用方法是对象名.方法名()。 3.public static void 方法名(). 静态成员函数。这个函数不属于某个具体的对象，这个类实例化的每个成员都可用，同时，这个类也可以直接调用这个函数而不用实例化一个对象。 ...
Java中的方法
weixin_48548208的博客
07-13 328
注意: 方法必须先创建才可以使用，该过程成为方法定义 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用 无参方法的定义和调用 方法的调用格式 ​ 在mian方法中，通过方法名调用​ 方法名();每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。​ main方法先执行​ main方法先被调用，随后执行main方法中的逻辑代码，当遇到了调用自定义方法的语句，执行自定义方法
java面向对象笔记.pdf
11-27
java面向对象笔记.pdf
Java面向对象-笔记.docx
12-17
Java面向对象-笔记.docx
java面向对象课堂笔记.pdf
11-29
java面向对象课堂笔记.pdf
JAVA面向对象笔记.md
01-12
本篇笔记阐述了Java中面向对象的核心概念：类作为创建对象的模板，封装通过private关键字实现数据隐藏及getter/setter方法访问控制；继承允许子类扩展和重用父类属性与方法；多态性体现为一个接口或父类在不同子类中...
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1357
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 871
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1193
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 484
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java多线程创建方式
weixin_57763462的博客
05-28 1037
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 768
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1040
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 153
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
继承与无参构造器
2301_79842503的博客
05-30 185
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
java有道云,有道云笔记链接——JAVA面向对象的学习
05-14
很抱歉，我无法提供有道云笔记的链接，但我可以向您推荐一些学习Java面向对象的资源： 1. Java面向对象编程基础课程 - 网易云课堂 2. Java面向对象编程基础 - 廖雪峰的官方网站 3. Java面向对象编程 - 百度文库 4. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王博1999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值