面向对象编程（高级）

面向对象编程（高级）

1、类变量和类方法

（1） 概念

类变量，也称为静态变量，是指在类级别声明的变量。它们与特定类相关联，而不是与类的实例（对象）相关联。每个类变量只有一份副本，它被类的所有实例共享。

static 变量保存在Class实例的尾部。而class对象确实存在堆中，所以，可以认为，static放在堆中

理解：

  • static变量是同一个类所有对象共享
  • static类变量，在类加载的时候就生成了

类方法（静态方法）是与类本身相关联的方法，而不是与类的实例（对象）相关联。它们可以直接通过类名调用，不需要实例化对象。当方法中不涉及到任何对象相关的成员，就可以将方法设计成静态方法，提高开发效率。

举例：比如工具类里面的方法utils，Math类、Arrays类、Collections集合

（2）定义
类变量语法：
   1、 访问修饰符 static 数据类型 变量名;(推荐)
   2、 static 访问修饰符 数据类型 变量名;

类方法语法：
   1、 访问修饰符 static 数据返回类型 方法名（）{};(推荐)
   2、 static 访问修饰符 数据返回类型 方法名（）{};
（3）访问
类变量访问：
   1、 类名.类变量名  (推荐)  静态变量的访问修饰符的访问权限和范围和普通变量是一样的。
   2、 对象名.类变量名
    
类方法访问：
   1、 类名.类方法名  (推荐)  静态变量的访问修饰符的访问权限和范围和普通变量是一样的。
   2、 对象名.类方法名

举例：

类变量：

public class StaticTest {
    public static void main(String[] args) {
        //类名.类变量名
        //类变量是随着类的加载而创建，不用创建对象也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名也可以访问
        System.out.println(a.name);
    }
}

class A{
    //类变量也需要遵循相关的访问权限
    public static String name = "你好";
    //普通属性/普通成员变量/非静态属性/非静态成员变量
    private int num = 10;
}

类方法：

public class Student {
    public static void main(String[] args) {
        //类.类方法进行调用
        Stu.Pay(100);
        Stu.Pay(200);
        Stu.Show();
        System.out.println(MyTools.calSum(10,30));
    }
}

//开发自己的工具类，可以将方法做成静态的，方便调用
class MyTools{
    public static double calSum(double n1, double n2){
        return n1 + n2;
    }
}

class Stu{
    public static double totalFee = 0;
    private String name;

    public Stu(String name) {
        this.name = name;
    }
    //1、方法使用static修饰时，该方法就为静态方法
    //2、静态方法只能访问静态变量
    public static void Pay(double fee){
        Stu.totalFee += fee;
    }
    public static void Show(){
        System.out.println("总学费为"+totalFee);
    }
}
（4）注意事项和细节

  1. 什么时候需要用类变量

    需要某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）

  2. 类变量和实例变量（普通变量）的区别

    类变量时类的所有对象共享，实例变量是每个对象共享

  3. 实例变量不能通过 类名.类变量名，进行访问

  4. 静态变量是类加载的时候，就创建了，所以不需要实例化对象，也可以访问

  5. 类变量的声明周期是随着类的加载开始，随着类消亡而销毁

  6. 静态方法（类方法）只能访问静态成员

  7. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区，类方法中无this参数，普通方法中隐藏着this参数。普通方法主要不能直接通过类名.类方法进行调用

  8. 类方法中不允许使用和对象有关的关键字，比如this和super，普通方法可以

（5）类方法与普通方法的对比
特点普通方法（实例方法）类方法（静态方法）
关联实例隶属于类的实例，通过实例化对象调用不隶属于特定对象实例，直接通过类名调用
访问实例变量可以访问和操作实例变量和实例方法，也可以访问静态方法、静态变量不能直接访问实例变量或实例方法，只能访问静态方法和静态变量
this、super关键字可以在方法中使用 this 关键字、super关键字不能在方法中使用 this 或 super 关键字
动态绑定支持动态绑定，根据对象类型执行方法不支持动态绑定，根据类类型执行方法
非静态上下文在对象实例上下文中执行在静态上下文中执行

2、理解main方法

public static void main(String[] args){}

  1. main方法是虚拟机调用的

  2. java虚拟机需要调用类的main方法（不同类、不同包），所以该方法的访问权限必须是public

  3. java虚拟机在执行main（）方法的时候不用创建对象，所以该方法是static

  4. 该方法接受String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

    java 执行的程序 参数1 参数2 参数3

  5. main方法中，可以直接调用main所在类的静态方法和静态属性，但是不能使用非静态方法和属性，除非创建该类的实例对象之后，才能通过这个对象去访问类的

IDEA如果给main函数传参：

在这里插入图片描述

3、代码块

（1）概念

代码块是初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体重，通过{}包围起来。但与方法不同，没有方法名，参数和返回值，只有方法体， 不需要对象或者类显示的调用，而是加载类，或创建对象时隐式的调用。

（2）语法
[修饰符]{
    代码
};
  1. 修饰符可选，要么不写，要么就是static，写了static的代码块叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块
  2. 最后面的分号可写可不写。里面的代码可以是任何的逻辑语句（比如：输入、输出、方法调用，循环，判断等等）
  3. 相当于另外一种形式的构造器（对于构造器的补充机制），可以做初始化的操作，如果多个构造器里面都有重复的雨具，可以抽取到初始化块当中，提高代码的重用性。
（3）注意事项

  1. 静态代码块（static），作用是对类进行初始化，随着类的加载而执行，并且 只会执行一次，如果是普通的代码块，每创建一个对象，就会执行。

  2. 类什么时候被加载？【重要】

    1. 创建对象实例时（new）
    2. 创建子类对象实例，父类会被加载
    3. 使用类的静态成员时（静态属性、静态方法）

  3. 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会被调用一次。如果只是使用类的静态成员时，普通代码块并不会执行。

  4. 创建对象时，一个类的调用顺序【重点和难点】：

    1. 调用静态代码块和静态属性的位置（多个则按顺序来）
    2. 调用普通代码块和普通属性（多个按顺序来）
    3. 调用构造方法

    举例：

    package JavaEE.chapter08.CodeBlock;

public class CodeBlockDetail02 {
    public static void main(String args[]){
        A a = new A();
    }
}

class A{
    private int n2 = getN2();
    private static int n1 = getN1();

    {
        System.out.println("A的普通代码块");
    }

    static {
        System.out.println("A的静态代码块");
    }

    public static int getN1(){
        System.out.println("getn1被调用");
        return 100;
    }

    public int getN2(){
        System.out.println("A普通方法被调用");
        return 200;
    }

    public A(){
        System.out.println("无参构造器");
    }

}

/*输出
getn1被调用
A的静态代码块
A普通方法被调用
A的普通代码块
无参构造器
*/

  5. 构造器的最前面隐含了super()和调用普通代码块，静态相关的代码块，属性初始化在类加载的时，就执行完毕了，因此是优先于构造器和普通代码块执行的。

    举例：

    class A{
    public A(){	//构造器
        //隐藏的执行要求
        //(1)super();
        //(2)调用普通代码块
        System.out.println("无参构造器");
    }
}

  6. 创建子类对象时，静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法调用顺序：

    1. 父类的静态代码块和静态属性
    2. 子类的静态代码和静态属性
    3. 父类的普通代码块和普通属性
    4. 父类的构造方法
    5. 子类的普通代码块和普通属性
    6. 子类的构造方法

    个人总结：

    1. 类加载（父类->子类）相关static代码执行
    2. 构造器
      1. super（父类）
      2. 普通代码块
      3. 构造方法

  7. 静态代码块只能调用静态成员，普通方法可以调用任意成员。

4、单例设计模式

（1）设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构，编程风格，以及解决问题的思考方式。

（2）单例设计模式介绍

  1. 单例设计模式就是在整个的软件系统中，采取一定的方法保证某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

  2. 实现方式

    1. 饿汉式（还没有用到对象，可能对象已经创建好）

      • 构造器私有化
      • 类的内部构造对象
      • 向外暴露一个静态的公共方法返回对象

      ​ 举例：

      class GirlFriend {
    private String name;

    //第一步：将构造器私有化
    private GirlFriend(String name){
        this.name = name;
    }

    //第二步，在类的内部直接创建静态对象
    private static GirlFriend gf = new GirlFriend("小红");

    //第三步：提供一个公共的static方法，返回gf对象
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

    2. 懒汉式（只有当用户使用getInstance的时候，才返回对象，再次调用时，返回是上次创建的cat对象）

      • 第一步：构造器私有化
      • 第二步：定义一个新的static静态对象
      • 第三步：提供一个public的static方法，可以返回一个对象

      举例：

      //单例设计模式的懒汉式
class Cat{
    private String name;
    public static int n1 = 999;

    //第一步：构造器私有化
    private Cat(String name) {
        System.out.println("类加载。。。。");
        this.name = name;
    }

    //第二步：定义一个新的static静态对象
    private static Cat cat;

    //第三步：提供一个public的static方法，可以返回一个Ca对象
    public static Cat getInstance(){
        //还没有对象，就创建对象
        if(cat == null){
            cat = new Cat("小花喵");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}
（3）饿汉式和懒汉式对比
  1. 饿汉式是在类加载的时候就创建了对象实例，而懒汉式是在使用时才创建
  2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题
  3. 饿汉式存在浪费资源的可能，懒汉式不存在这个问题
  4. javaSE中，java.lang.Runtime是一个经典的单例模式

5、FINAL 关键字

final 是 Java 中的一个关键字，它可以确保常量的值不会被修改。对于方法和类，它可以确保方法实现或类结构不会被修改或继承改变，这在某些情况下有助于代码的安全性和性能优化。

（1）final应用场景
  1. 对变量使用 final：
    • 当应用于变量时，final 关键字表示该变量只能被赋值一次。一旦赋值后，就不能再更改。这适用于基本数据类型和对象引用。
    • 例如：final int x = 10; 声明了一个只能被赋值一次的整数变量 x。
  2. 对方法使用 final：
    • 当应用于方法时，final 表示该方法不能被子类重写（覆盖）。
    • 例如：final void someMethod() { // do something } 定义了一个不能被子类重写的方法。
  3. 对类使用 final：
    • 当应用于类时，final 表示该类不能被继承，即它是最终的，不能有子类。
    • 例如：final class MyClass { // class definition } 声明了一个不能被继承的类。
（2）注意事项

  1. final修饰的属性又叫做常量，一般用用XX_XX来命名（大写加下划线）

  2. final修饰的属性必须赋初值，并且以后不能被修改，赋值可以有以下三个地方可以进行：

    1. 定义，例如： public final double TAX_RATE = 0.5;
    2. 构造器中
    3. 代码块中

  3. 如果final修饰的属性是静态的，初始化的位置只能是：

    1. 定义中
    2. 静态代码块中

  4. 类不是final类，但是含有final方法，方法不能被重写，但是可以被继承

    举例：

    public class FinalDetail01 {
    public static void main(String[] args) {
        BB bb = new BB();
        bb.cal();
    }
}
class AA{
    final public void cal(){
        System.out.println("CAL方法");
    }
}
class BB extends AA{

}

  5. 一般来说，一个类已经是final类了，没有必要再将方法修饰成final方法。（因为已经无法被继承了）

  6. final不能修饰构造方法（即构造方法）

  7. final和staic往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理

    举例：

    class Demo{
    public final static int n1 = 16;
    static {
        System.out.println("这里是类加载，不会被执行");
    }
}

  8. 包装类（Integer，Double，Float，Boolean等都是final）String也是final类。

6、抽象类

（1）介绍

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。抽象类通常用于当我们希望有一个通用的类定义，但其中的某些方法在基类中并不具备实际的实现，而是应该由具体的子类来实现。在框架和设计模式比较多

举例：

//抽象类不能被实例化，有抽象方法，这个类必须声明为abstract
abstract class AA{
    //抽象方法没有方法体
    public abstract void eat();
}
（2）注意事项

  1. 抽象类不能被实例化

  2. 抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类。

    举例：

    abstract class BB{
    public void cal(){
        System.out.println("抽象类可以没有抽象方法");
    }
}

  3. 抽象类只能修饰类和方法，不能修饰属性和其他的类型。

  4. 抽象类可以有任意成员 （抽象类本质还是类），比如：非抽象方法、构造器、静态属性等。

    举例：

    abstract class BB{
    //属性
    private String name;
    //构造器
    public BB() {
    }
    //普通方法
    public void cal(){
        System.out.println("抽象类可以没有抽象方法");
    }
    //抽象方法，没有方法体
    abstract void hi();
}

  5. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

    举例：

    abstract  class E{
    public abstract void hi();
    public abstract void sorry();
}
//子类必须实现父类的所有抽象方法
class F extends E{
    public void hi(){
        System.out.println("hi");
    }
    public void sorry() {
        System.out.println("sorry");
    }
}

  6. 抽象方法不能用private、final和static来修饰，因为这些关键字是与重写相违背的。

（3）抽象类实践-模版设计模式

抽象类体现的是一种模版模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展，改造，但子类总体会保留抽象类的行为模式。

可以解决的问题有：

  1. 当功能内部一部分是确定的，一部分是不确定的，这时可以把不确定的部分暴露出去，让子类去实现
  2. 编写一个抽象父类，父类提供多个子类的通用方法，并把一个活多个方法留给子类实现，这个就是模版设计模式。

举例：

abstract class Template{
    public abstract void job();

    //一部分抽象，一部分不抽象，可以转变为一个模板，提供给子类实现
    public void calculate(){
        long time = System.currentTimeMillis();
        job();
        long nowtime = System.currentTimeMillis();
        System.out.println("该任务执行时间为："+(nowtime-time));
    }
}

class Cat extends Template{
    //子类只需要负责实现抽象部分即可
    public void job(){
        long sum = 0;
        for (int i = 0; i < 8000000; i++) {
            sum += i*2;
        }
    }
}

class Tiger extends Template{
    //子类只需要负责实现抽象部分即可
    public void job(){
        long sum = 0;
        for (int i = 0; i < 8000000; i++) {
            sum += i;
        }
    }
}

7、接口

（1） 基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类需要使用的时候，在根据具体情况把这些方法写出来

语法：

interface 接口名{
    //属性
    //方法
}

class 类名 implements 接口{
    //自己属性
    //自己方法
    //必须实现的接口的抽象方法
}
//Jdk7.0之前，接口里面的所有方法都没有方法体
//Jdk8.0之后，接口中可以有方法的具体实现（默认方法、或者静态方法）

接口是更加抽象的抽象的类，Jdk8.0之后，接口类里面可以用静态方法，默认方法，可以有具体方法的实现。

举例：

interface AInterface{
    public int n1 = 10;
    //抽象方法
    public void hi();
    //使用关键字default修饰之后，可以实现具体的方法
    default void ok(){
        System.out.println("这里可以声明方法");
    }
    //使用static修饰之后，也可以实现具体的方法
    static void you(){
        System.out.println("这里可以声明方法");
    }
}

//需要实现接口类的所有抽象方法
class A implements AInterface{
    @Override
    public void hi() {
        System.out.println("实现接口类的抽象方法");
    }
}
（2）注意事项

  1. 接口不能被实例化

  2. 接口中所有的方法都是public方法，接口中的抽象方法，可以不用abstract修饰

    void aaa();
实际上等同于 public abstract void aaa();

  3. 一个普通类实现接口，就必须将该接口的所有方法都实现。而抽象类实现接口，就可以不用实现接口的方法。

    interface AInterface{
    //抽象方法
    public abstract void hi();
}

//抽象类可以不用实现抽象方法
abstract class B implements AInterface{
}

  4. 一个类可以实现多个接口

    interface  AI{}
interface BI{}
class BC implements AI, BI{}

  5. 接口中的属性，只能是final，而且是public static final修饰符，比如：int a = 1;实际上是 public static final int a = 1（必须初始化），属性访问形式：接口名.属性名

  6. 接口不能继承其他的类，但是可以继承多个别的接口

    interface  AI{}
interface BI{}
interface BD extends AI,BI{}

  7. 接口的修饰符，只能是public或者是默认的， 这里和普通的类一样

（3）接口对比继承

接口是对行为的抽象，而继承是对类的抽象。 当子类继承了父类，就自动拥有父类的功能。如果子类需要扩展功能，可以通过实现接口的方式扩展。可以理解为接口是对单继承机制的一种补充。

  1. 继承的价值：解决代码的复用性和可维护性（is - a关系）
  2. 接口的价值：设计好各种规范（方法），让这些类去实现这些诶方法，更加的灵活。（like -a 关系）
  3. 接口在一定程度上可以实现代码的解耦（接口规范性+动态绑定）
（4） 接口多态

  1. 接口的多态

  2. 多态数组

    以上两种举例：

    public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态，
        //接口类型的变量 if01可以指向实现了IF接口的类的对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //多态数组
        IF[] if02 = new IF[2];
        if02[0] = new Monster();
        if02[1] = new Car();
    }
}

interface IF{}
class Monster implements IF {}
class Car implements  IF{}

  3. 接口多态传递

public class InterfacePoly {
    public static void main(String[] args) {
        //接口类型变量可以指向，实现该接口的类的对象实例
        IG ig = new Teacher();
        //IG继承了IH接口，Teacher实现了IG接口，相当于Teacher实现了IH接口，这就是接口的多态传递现象
        IH ih = new Teacher();
    }
}
interface IH{}
interface IG extends IH{}
class Teacher implements IG{}

8、内部类【难点和重点】

（1）基本介绍

一个类的内部有完成的嵌套了另外一个类的结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是类的第五大成员（属性、方法、构造器、代码块、内部类），内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。在很多源码当中都有大量内部类。

举例：

//类的五大成员
class Outer{//外部类
    //属性
    private int n1 = 100;
    
    //构造器
    public Outer(int n1) {
        this.n1 = n1;
    }
    //方法
    public void m1(){
        System.out.println("方法");
    }
    //代码块
    {
        System.out.println("代码块...");
    }
    //内部类
    class Inner{//内部类，在Outer类的内部
        
    }
}

内部类的种类：

  1. 在局部位置（方法/代码块）：
    1. 局部内部类（有类名）
    2. 匿名内部类（没有类名，重点）
  2. 成员位置：
    1. 成员内部类（没有static修饰）
    2. 静态内部类（有static修饰）

基本语法：

class Outer{//外部类
    class Inner{//内部类
    }
}
（2）局部内部类

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

  1. 可以直接访问外部类的所有成员，包含私有成员
  2. 不能添加访问修饰符，因为这是一个局部变量，可以使用final，局部变量可以使用final
  3. 作用域：仅仅在定义它的方法或者代码块中
  4. 局部内部类—访问---->外部类的成员[访问方式：直接访问]
  5. 外部类—访问—>局部内部类的成员[访问方式：创建对象后，再访问（必须在作用域内）]
  6. 外部其他类—不能访问---->局部内部类
  7. 如果外部类与局部内部类的成员重名时，遵循就近访问原则，如果想访问外部类的成员可以使用[外部类名.this.成员]去访问

举例：

class Outer02{//外部类
    private int n1 = 10;
    private void m2(){}//私有方法
    public void m1(){//方法
        //1、局部内部类是定义在外部类的局部位置，通常实在方法里面
        //3、不能添加访问修饰符，但是可以使用final修饰（不能被继承）
        //4、作用域：仅仅在方法或代码块中
        class Inner02{  //局部内部类（本质仍为一个类）
            private int n1 = 800;
            public void f1(){
                //2、可以直接访问外部类的所有成员，包含私有的
                //5、局部内部类可以直接访问外部类的成员，比如n1，m2()
                //7、如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，可以使用 外部类名.this.成员去访问
                //Outer02.this 的本质就是外部类的对象，哪个对象调用了m1，Outer02.this就是哪个对象
                System.out.println("内部类n1= "+n1);
                System.out.println("外部类的n1 ="+Outer02.this.n1);
                m2();
            }
        }
        //6、外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

注意事项：

  • 局部内部类定义在方法中/代码块中
  • 作用域在方法体或者代码块中
  • 本质仍然是一个类
（3）匿名内部类（重要）

匿名内部类是一个没有类名的内部类。如果一个内部类的对象在一个地方只需要用一次，那么我们可以使用匿名内部类，它可以简化代码，使得代码更易于阅读。匿名内部类在编译的时候由系统自动用其父类名加$1、$2这样的方式来命名。

匿名内部类定义在外部类的局部位置，比如方法中，并且没有类名

基本语法：

new 类或接口(参数列表){
    类体
};
//参数列表会传给类的构造器

举例：

class Outer04{//外部类
    private int n1 = 10;//属性
    public void method(){//方法
        //基于接口的匿名内部类
        //1、需要A接口，并创建对象
        //2、传统方法，是写一个类，实现接口，并创建对象
        //3、只需要使用一次，后面不需要再使用
        //4、使用匿名内部类简化开发
        //5、匿名内部类tiger的运行类型为 Outer04$1，编译类型是A
        //6、匿名内部类的底层实现：
        /*
            class Outer04$ implement A{
                public void cry() {
                System.out.println("老虎在叫");
                }
            }
         */
        //7、jdk在底层创建匿名内部类Outer04$1,立马就创建了Outer04$01实例，并且把地址返回
        //8、匿名内部类使用一次就不再使用
        A tiger = new Tiger(){
            public void cry() {
                System.out.println("老虎在叫");
            }
        };
        tiger.cry();
//        A tiger = new Tiger();
//        tiger.cry();
    }
}

interface A{//接口
    public void cry();
}

class Tiger implements A{
    @Override
    public void cry() {
        System.out.println("老虎在叫");
    }
}

注意事项：（与局部内部类类似）

  1. 语法比较不一样，既有定义类的特征，也有创建对象的特征。
  2. 可以直接访问外部类的所有成员，包含私有成员
  3. 不能添加访问修饰符，因为这是一个局部变量，可以使用final，局部变量可以使用final
  4. 作用域：仅仅在定义它的方法或者代码块中
  5. 外部其他类—不能访问---->局部内部类
  6. 如果外部类与局部内部类的成员重名时，遵循就近访问原则，如果想访问外部类的成员可以使用[外部类名.this.成员]去访问

实践：

public class AnonymousClassPractice {
    public static void main(String[] args) {
        //1、将匿名内部类直接当做实参传入函数当中
        f1(new Fot() {//软编码模式
            @Override
            public void show() {
                System.out.println("匿名内部类重写show方法");
            }
        });
        //正常实现,比较麻烦
        Example example = new Example();
        f1(example);
    }

    public static void f1(Fot fot){
        fot.show();
    }
}

interface Fot{
    void show();
}

//硬编码模式
class Example implements Fot{
    @Override
    public void show() {
        System.out.println("普通类重写show方法");
    }
}
（4）成员内部类

成员内部类是创建在外部类的成员位置，没有static修饰

注意事项：

  1. 可以直接访问外部类的所有成员，包含私有成员
  2. 可以添加任意的修饰符（public、protected、private、默认），可以认为这个类就是一个成员
  3. 作用域是和其他类的成员一样，是整个类体
  4. 成员内部类-----访问----->外部类成员（比如：属性）【访问方式：直接访问】
  5. 外部类------访问------>成员内部类【访问方式：创建对象，再访问】
  6. 外部其他类-----访问----->成员内部类【两种方式：外部类名.new 内部类名，或者外部类名创建一个方法返回内部类】
  7. 如果外部类和内部类的成员重名时，内部类访问遵循就近原则，如果想访问外部类的成员，可以使用（外部类名.this.成员）去访问

举例：

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类，访问成员内部类的两种种方式；
        //第一种方式：把内部类当做外部类的一个成员来使用
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();

        //第二种方式，在Outer里面创建一个方法，这个方法返回一个内部类地址
        Outer08.Inner08 inner081 = outer08.getInner08Instance();
        inner081.say();

    }
}

class Outer08{
    private int n1 = 10;
    public String name = "张三";
    //1、内部类是定义在外部类的成员位置
    //2、可以用public、private、protected修饰
    //3、作用域在整个类体
    class Inner08{//成员内部类
        public void say(){
            //4、可以访问外部类的所有成员，包含私有的
            System.out.println("n1 = "+n1 + " name = "+name);
        }
    }

    public void t1(){
        //5、外部类使用内部类，创建对象，使用他的成员即可
        Inner08 inner08 = new Inner08();
        inner08.say();
    }

    public Inner08 getInner08Instance(){
        return new Inner08();
    }
}
（5）静态内部类

静态内部类是定义在外部类的成员位置，并且有static修饰，与成员内部类基本没有区别

注意事项：

  1. 可以直接访问外部类的所有成员，包含私有成员
  2. 可以添加任意的修饰符（public、protected、private、默认），可以认为这个类就是一个成员
  3. 作用域是和其他类的成员一样，是整个类体
  4. 成员内部类-----访问----->外部类成员（比如：属性）【访问方式：直接访问】
  5. 外部类------访问------>成员内部类【访问方式：创建对象，再访问】
  6. 外部其他类-----访问----->成员内部类【两种方式：外部类名.new 内部类名，或者外部类名创建一个方法返回内部类】
  7. 如果外部类和内部类的成员重名时，内部类访问遵循就近原则，如果想访问外部类的成员，可以使用（外部类名.成员）去访问 【不需要加this】

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/294684.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【docker】cgroups资源限制

【docker】cgroups资源限制

目录 一、cpu资源控制 1、 设置cpu使用率上限 2、设置cpu资源占用比&#xff08;设置多个容器时才有效&#xff09;Docker通过–cpu-shares指定cpu份额&#xff0c;默认为1024&#xff0c;值为1024的倍数。 3、设置容器绑定指定的CPU 三、内存资源控制 四、磁盘IO配额控制…
阅读更多...
恭喜 Databend 上榜 2023 开源创新榜「优秀开源项目 」

恭喜 Databend 上榜 2023 开源创新榜「优秀开源项目 」

近日&#xff0c;国家科技传播中心见证了一场开源界的重要事件&#xff1a;由中国科协科学技术传播中心、中国计算机学会、中国通信学会和中国科学院软件研究所联合主办&#xff0c;CSDN 承办的 2023 年开源创新榜专家评审会圆满落幕。由王怀民院士担任评委会主任&#xff0c;评…
阅读更多...
MR实战：词频统计

MR实战：词频统计

文章目录 一、实战概述二、提出任务三、完成任务&#xff08;一&#xff09;准备数据1、在虚拟机上创建文本文件2、上传文件到HDFS指定目录 &#xff08;二&#xff09;实现步骤1、创建Maven项目2、添加相关依赖3、创建日志属性文件4、创建词频统计映射器类5、创建词频统计归并…
阅读更多...
如何搭建HomeAssistant智能家居管理平台并实现公网访问内网管理界面

如何搭建HomeAssistant智能家居管理平台并实现公网访问内网管理界面

目录 前言 一、下载HomeAssistant镜像 二、内网穿透HomeAssistant&#xff0c;实现异地控制智能家居 三、使用固定域名访问HomeAssistant 结语 前言 作者简介&#xff1a; 懒大王敲代码&#xff0c;计算机专业应届生 今天给大家聊聊如何搭建HomeAssistant智能家居管理平台…
阅读更多...
数据结构之哈希——学习笔记

数据结构之哈希——学习笔记

今天看网课学习了哈希的数据结构&#xff0c;写下这一篇博客记录自己的学习过程。 1.哈希简介&#xff1a; 我们发现某些时候映射到小集合的时候会同时有多个值映射到一个下标里面&#xff0c;所以接下来是这种情况的解决方案1&#xff1a; 我们考虑当两个数字映射之后的结果…
阅读更多...
Python startswith()和endswith()方法及 index()方法：检测字符串中是否包含某子串

Python startswith()和endswith()方法及 index()方法：检测字符串中是否包含某子串

Python startswith()和endswith()方法 Python 字符串变量还可以使用 startswith() 和endswith() 方法。 startswith()方法 startswith() 方法用于检索字符串是否以指定字符串开头&#xff0c;如果是返回 True&#xff1b;反之返回 False。此方法的语法格式如下&#xff1a; …
阅读更多...
向日葵远程工具的使用Mysql5.7的安装与配置

向日葵远程工具的使用Mysql5.7的安装与配置

目录 一、向日葵远程安装与使用 二、Mysql 5.7 安装与配置 2.1 安装 2.2 Navicat Premium 12 测试连接 本机测试连接 外部访问MySQL测试连接 三、思维导图 一、向日葵远程安装与使用 简介&#xff1a; 向日葵远程控制是一款用于对远程PC进行管理和服务的软件,拥有5秒快速…
阅读更多...
isEmpty 和 isBlank 的用法区别，居然一半的人答不上来.....

isEmpty 和 isBlank 的用法区别，居然一半的人答不上来.....

isEmpty 和 isBlank 的用法区别 isEmpty系列isBank系列 hi&#xff01;我是沁禹&#xff5e; 也许你两个都不知道,也许你除了isEmpty/isNotEmpty/isNotBlank/isBlank外,并不知道还有isAnyEmpty/isNoneEmpty/isAnyBlank/isNoneBlank的存在, come on ,让我们一起来探索org.apache…
阅读更多...
网络调试 TCP，开发板用静态地址-入门4

网络调试 TCP，开发板用静态地址-入门4

用两台电脑&#xff08;无线网络&#xff09;做实验 1.1, 在电脑A上设置为Server如下&#xff1a; 选择TCP Server后&#xff0c;直接跳出用本机IP做为“本地主机地址” 1.2在 电脑B上设置为Client, 远程主机地址设置为Server的 IP 1.3, 在A, B两台电脑上能够互相发送数据 用…
阅读更多...
[C语言]程序设计（四）

[C语言]程序设计（四）

大家好&#xff0c;这里是争做图书馆扫地僧的小白。非常感谢各位的支持&#xff0c;也期待着您的关注。 目前博主有着C语言、C、linux以及数据结构的专栏&#xff0c;内容正在逐步的更新。 希望对各位朋友有所帮助同时也期望可以得到各位的支持&#xff0c;有任何问题欢迎私信与…
阅读更多...
架构（1）

架构（1）

目录 1.如何理解架构的演进&#xff1f; 2.如何理解架构的服务化趋势&#xff1f; 3.架构中有哪些技术点&#xff1f; 4.谈谈架构中的缓存应用&#xff1f; 5.在开发中缓存具体如何实现&#xff1f; 1.如何理解架构的演进&#xff1f; 初始阶段的网站架构应用服务和数据服…
阅读更多...
OpenAI ChatGPT-4开发笔记2024-02：Chat之text completion

OpenAI ChatGPT-4开发笔记2024-02：Chat之text completion

API而已 大模型封装在库里&#xff0c;库放在服务器上&#xff0c;服务器放在微软的云上。我们能做的&#xff0c;仅仅是通过API这个小小的缝隙&#xff0c;窥探ai的奥妙。从程序员的角度而言&#xff0c;水平的高低&#xff0c;就体现在对openai的这几个api的理解程度上。 申…
阅读更多...
自存react crash course（1）

自存react crash course（1）

1.创建一个react 项目 确保有node.js 创建名为react-task-tracker的react项目 npx create-react-app react-task-tracker 启动项目 npm start2.项目结构 所有组件都是放在src下面的 3. jsx // jsx语法 和html很像&#xff0c;class用的是className来使用css的样式<div…
阅读更多...
vue3 实现关于 el-table 表格组件的封装以及调用

vue3 实现关于 el-table 表格组件的封装以及调用

一、示例图&#xff1a; 二、组件 <template><div class"sn-table" :class"props.colorType 1 ? : bg-scroll"><el-table :data"tableData" :row-class-name"tableRowClassName" height"500" style"…
阅读更多...
Ubuntu20 编译 Android 12源码

Ubuntu20 编译 Android 12源码

1.安装基础库 推荐使用 Ubuntu 20.04 及以上版本编译&#xff0c;会少不少麻烦&#xff0c;以下是我的虚拟机配置 执行命令安装依赖库 // 第一步执行 update sudo apt-get update//安装相关依赖sudo apt-get install -y libx11-dev:i386 libreadline6-dev:i386 libgl1-mesa-de…
阅读更多...
海思SD3403/SS928V100开发（12）OSD显示开发

海思SD3403/SS928V100开发（12）OSD显示开发

1.前言 由于需要显示一些硬件状态，暂时还没开发GUI； 所以可以使用海思平台的OSD硬件叠层来做， 下面是做的一些调试记录 2. 翻阅MPP文档 有几个地方需要注意的地方 建议使用OVERLAYER类型，支持模块多很多，还可以直接叠VO模块 3. sample测试 3.1 sample region samp…
阅读更多...
阿贝云免费云服务器

阿贝云免费云服务器

最近体验了一下阿贝云的免费云服务器&#xff0c;总体感受是简单易上手。感兴趣的小伙伴们可以赶紧注册体验一下。 阿贝云官网&#xff1a; https://www.abeiyun.com 下图是我亲测的免费云服务器管理界面&#xff0c;免费云服务器的配置信是1核1GB&#xff0c;硬盘10GB&#x…
阅读更多...
森林火灾图像数据集

森林火灾图像数据集

目标是使用该数据集开发一个可以识别火焰图像的模型。收集数据是为了训练模型来区分包含火灾的图像&#xff08;火灾图像&#xff09;和常规图像&#xff08;非火灾图像&#xff09;&#xff0c;因此整个问题是二元分类。数据分为2个文件夹&#xff0c;fire_images文件夹包含75…
阅读更多...
DASS最新论文整理@2023.12

DASS最新论文整理@2023.12

CVPR 2023 论文来源&#xff1a;https://openaccess.thecvf.com/CVPR2023?dayall 1 Planning-oriented Autonomous Driving 面向规划的自动驾驶 (Best papper) 项目地址&#xff1a;https://opendrivelab.github.io/UniAD/ 现代自动驾驶系统的特点是按顺序执行模块化任务…
阅读更多...
如何培养用户思维

如何培养用户思维

产品开发是根据用户要求建造出系统的过程&#xff0c;产品开发是一项包括需求捕捉、需求分析、设计、实现和测试的系统工程&#xff0c;一般通过某种程序设计语言来实现。然而用户思维能够帮助企业更好地理解市场需求&#xff0c;进行产品的开发和完善&#xff0c;用户是企业产…
阅读更多...
最新文章

Copyright @ 2022~2023