【Java从入门到大牛】面向对象进阶下篇

ゞ浴缸里的玫瑰 2024-04-26 02:46 76阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[Java从入门到大牛][Java]  
> ? 首发时间：2023年7月19日  
> ? 欢迎关注?点赞?收藏?留言?  
> ? 一以贯之的努力 不得懈怠的人生

#### 目录 ####

*  内部类
 *   *  内部类概述
     *  成员内部类（了解）
     *  静态内部类（了解）
     *  局部内部类（了解）
     *  匿名内部类（重点）
 *  枚举
 *   *  认识枚举
     *  枚举的常见应用场景
 *  泛型
 *   *  认识泛型
     *  泛型类
     *  泛型接口
     *  泛型方法、泛型通配符、上下限
     *  泛型的注意事项：擦除问题、基本数据类型问题
 *  java.lang包下的常用API
 *   *  API概述
     *  Object类
     *  Objects
     *  包装类
     *  StringBuilder、StringBuffer
     *  StringJoiner

## 内部类 ##

### 内部类概述 ###

**什么是内部类**

*  是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类
 *  场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必须单独设计时，就可以把这个事物设计成内部类
    
        public class Car {
              
        	// 内部类
        	public class Engine {
              
        	}
        }

**内部类有四种形式**

成员内部类、静态内部类、局部内部类、匿名内部类

### 成员内部类（了解） ###

**什么是成员内部类**

就是类中的一个普通成员，类似前面我们学过的普通的成员变量和成员方法

注意：JDK16 之前，成员内部类中不能定义静态成员，JDK16 开始也可以定义静态成员了

**创建对象的格式**

外部类名.内部类名 对象名 = new 外部类(...).new 内部类(...);
    Outer.Inner in = new Outer().new Inner();

**成员内部类中访问其他成员的特点**

1.  和前面学过的实例方法一样，成员内部类的实例方法中，同样可以直接访问外部类的实例成员和静态成员
2.  可以在成员内部类的实例方法中，拿到当前外部类对象，格式是：`外部类名.this`

### 静态内部类（了解） ###

**什么是静态内部类**

有 static 修饰的内部类，属于外部类自己持有

public class Outer {
        
    	// 静态内部类
    	public static class Inner {
        
    	}
    }

**创建对象的格式：**

外部类名.内部类名 对象名 = new 外部类.内部类(...);
    Outer.Inner in = new Outer.Inner();

**静态内部类中访问外部类成员的特点**

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员

### 局部内部类（了解） ###

**什么是局部内部类**

局部内部类定义在方法中、代码块中、构造器等执行体中（没什么用）

### 匿名内部类（重点） ###

**什么是匿名内部类**

*  就是一种特殊的局部内部类；所谓匿名指的是程序员不需要为这个类声明名字
    
        new 类或接口(参数值...) {
              
        	类体(一般是方法重写);
        };
        
        new Animal() {
              
        	@Override
        	public void cry() {
              
        	}
        };
 *  特点：匿名内部类本质就是一个子类，并会立即创建出一个子类对象
 *  作用：用于更方便地创建一个子类对象

**匿名内部类在开发中的使用场景**

通常作为一个参数传输给方法

**案例**

需求：猫、狗参加游泳比赛

**代码示例**

**Swimming.java**

public interface Swimming {
        
        void swim();
    }

**Test.java**

public class Test {
        
        public static void main(String[] args) {
        
            Swimming s1 = new Swimming() {
        
                @Override
                public void swim() {
        
                    System.out.println("小狗游泳飞快~~");
                }
            };
            go(s1);
    
            go(new Swimming() {
        
                @Override
                public void swim() {
        
                    System.out.println("小猫游泳也还行~~");
                }
            });
    
        }
    
        public static void go(Swimming s) {
        
            System.out.println("开始==============");
            s.swim();
        }
    }

## 枚举 ##

### 认识枚举 ###

**什么是枚举**

枚举是一种特殊类

**枚举类的格式**

修饰符 enum 枚举类名 {
        
    	名称1, 名称2, ...;
    	其他成员...	
    }
    
    public enum A {
        
    	X, Y, Z;
    	...
    }

**注意事项**

*  枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开
 *  这些名称，本质是常量，每个常量都会记住枚举类的一个对象

**枚举类的特点**

*  枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象
 *  枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象
 *  枚举都是最终类，不可以被继承
 *  枚举类中，从第二行开始，可以定义类的其他各种成员
 *  编辑器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum 类的，从 enum 类也会继承到一些方法

### 枚举的常见应用场景 ###

**用来表示一组信息，然后作为参数进行传输**

*  选择定义一个一个的常量来表示一组信息，并作为参数传输，参数值不受约束
 *  选择定义枚举表示一组信息，并作为参数传输。代码可读性好，参数值得到了约束，对使用者更友好

## 泛型 ##

### 认识泛型 ###

**什么是泛型**

*  定义类、接口和方法时，同时声明了一个或多个类型变量（如：<E>），称为泛型类、泛型接口或泛型方法，它们统称为泛型
    
        public class ArrayList<E> {
              
        	...
        }
 *  作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换及其可能出现的异常
 *  泛型的本质：把具体的数据类型作为参数传给类型变量

### 泛型类 ###

修饰符 class 类名<类型变量, 类型变量, ...> {
        
    	...
    }
    
    public class ArrayList<E> {
        
    	...
    }

注意：类型变量建议用大写的英文字母，常见的有：E、T、K、V 等

### 泛型接口 ###

修饰符 interface 类名<类型变量, 类型变量, ...> {
        
    	...
    }
    
    public interface A<E> {
        
    	...
    }

注意：类型变量建议用大写的英文字母，常见的有：E、T、K、V 等

### 泛型方法、泛型通配符、上下限 ###

**泛型方法**

修饰符 <类型变量, 类型变量, ...> 返回值类型 方法名(形参列表) {
        
    	...
    }
    
    public static <T> void test(T t) {
        
    	...
    }

**通配符**

就是 “?”，可以在 “使用泛型” 的时候代表一切类型；E T K V 是在定义泛型的时候使用

**泛型的上下限：**

*  泛型上限：`? extends Car`：？能接收的必须是 Car 或者其子类
 *  泛型下限：`? super Car`：？能接收的必须是 Car 或者其父类

**简单应用**

public class Car {
        
    }

public class BENZ extends Car{
        
    }

public class BMW extends Car{
        
    }

import java.util.ArrayList;
    
    public class Test {
        
        public static void main(String[] args) {
        
            // 目标：掌握泛型方法的定义和使用。
            String rs = test("java");
            System.out.println(rs);
    
            Dog d = test(new Dog());
            System.out.println(d);
    
            // 需求：所有的汽车可以一起参加比赛。
            ArrayList<Car> cars = new ArrayList<>();
            cars.add(new BMW());
            cars.add(new BENZ());
            go(cars);
    
            ArrayList<BMW> bmws = new ArrayList<>();
            bmws.add(new BMW());
            bmws.add(new BMW());
            go(bmws);
    
            ArrayList<BENZ> benzs = new ArrayList<>();
            benzs.add(new BENZ());
            benzs.add(new BENZ());
            go(benzs);
        }
    
        // ? 通配符，在使用泛型的时候可以代表一切类型   ? extends Car(上限)   ? super Car(下限)
        public static void go(ArrayList<? extends Car> cars){
        
    
        }
    
        public static <T extends Car> void go1(ArrayList<T> cars){
        
    
        }
    
        // 泛型方法
        public static <T> T test(T t){
        
            return t;
        }
    }

### 泛型的注意事项：擦除问题、基本数据类型问题 ###

**泛型的擦除问题和注意事项**

*  泛型是工作在编译阶段的，一旦程序编译成 class 文件，class 文件中就不存在泛型了，这就是泛型擦除
 *  泛型不支持基本数据类型，只能支持对象类型（引用数据类型）

## java.lang包下的常用API ##

### API概述 ###

**什么是API**

*  API（Application Programming Interface）：应用程序编程接口
 *  就是 java 帮我们已经写好一些程序，如：类、方法等，我们直接拿过来用就可以解决一些问题

**常用API**  
![在这里插入图片描述][9cc17cdc1e314c0e89ac94844c94c897.png]

### Object类 ###

**Object类的作用**

Object 类是 java 中所有类的祖宗类，因此，java 中所有类的对象都可以直接使用 Object 类中提供的一些方法

**Object类的常见方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public String toString()</code></td> 
   <td>返回对象的字符串表示形式</td> 
  </tr> 
  <tr> 
   <td><code>public boolean equals(Object o)</code></td> 
   <td>判断两个对象是否相等</td> 
  </tr> 
  <tr> 
   <td><code>protected Object clone()</code></td> 
   <td>对象克隆</td> 
  </tr> 
 </tbody> 
</table>

toString 存在的意义：为了被子类重写，以便返回对象具体的内容

equals 存在的意义：直接比较两个对象的地址是否相同完全可以用 “==” 替代 equals，equals 存在的意义就是为了被子类重写，以便子类自己来定制比较规则（比如比较对象内容）

clone 的作用：当某个对象调用这个方法时，这个方法会复制一个一模一样的新对象返回

**什么是浅克隆**

拷贝出的新对象，与原对象中的数据一模一样（引用类型拷贝的只是地址）

**什么是深克隆**

*  对象中基本类型的数据直接拷贝
 *  对象中的字符串数据拷贝的还是地址
 *  对象中还包含的其他对象，不会拷贝地址，会创建新对象

### Objects ###

**什么是Objects**

Objects 是一个工具类，提供了很多操作对象的静态方法给我们使用，使用其静态方法更安全

**Objects类的常见方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public static boolean equals(Object a, Object b)</code></td> 
   <td>先做非空判断，再比较两个对象</td> 
  </tr> 
  <tr> 
   <td><code>public static boolean isNull(Object obj)</code></td> 
   <td>判断对象是否为 null，为 null 则返回 true，反之</td> 
  </tr> 
  <tr> 
   <td><code>public static boolean nonNull(Object obj)</code></td> 
   <td>判断对象是否不为 null，不为 null 则返回 true，反之</td> 
  </tr> 
 </tbody> 
</table>

### 包装类 ###

**什么是包装类**

包装类就是把基本类型的数据包装成对象

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>对应的包装类（引用数据类型）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

基本类型的数据包装成对象的方案：`public static Integer valueOf(int i)`

自动装箱：基本数据类型可以自动转换为包装类型

自动拆箱：包装类型可以自动转换为基本数据类型

**包装类的其他常见操作**

*  可以把基本类型的数据转换成字符串类型
    
        public static String toString(double d)
        public String toString()
 *  可以把字符串类型的数值转换成数值本身对应的数据类型
    
        public static int parseInt(String s)
        public static Integer valueOf(String s)

### StringBuilder、StringBuffer ###

**什么是StringBuilder**

*  StringBuilder 代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的
 *  好处：StringBuilder 比 String 更适合做字符串的修改操作，效率会更高，代码也会更简洁

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public StringBuilder()</code></td> 
   <td>创建一个空白的可变的字符串对象，不包含任何内容</td> 
  </tr> 
  <tr> 
   <td><code>public StringBuilder(String str)</code></td> 
   <td>创建一个指定字符串内容的可变字符串对象</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public StringBuilder append(任意类型)</code></td> 
   <td>添加数据并返回 StringBuilder 对象本身</td> 
  </tr> 
  <tr> 
   <td><code>public StringBuilder reverse()</code></td> 
   <td>将对象的内容反转</td> 
  </tr> 
  <tr> 
   <td><code>public int length()</code></td> 
   <td>返回对象内容长度</td> 
  </tr> 
  <tr> 
   <td><code>public String toString()</code></td> 
   <td>通过 toString() 就可以实现把 StringBuilder 转换为 String</td> 
  </tr> 
 </tbody> 
</table>

**为啥操作字符串建议使用StringBuilder，而不用String?**

public class Test {
        
    	public static void main(String[] args) {
        
    		String s = "";
    		for (int i = 0; i < 1000000; i++) {
        
    			s = s + "abc";	// 很慢
    		}
    		System.out.println(s);
    	}
    }
    
    public class Test {
        
    	public static void main(String[] args) {
        
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < 1000000; i++) {
        
    			sb.append("abc");	// 很快
    		}
    		System.out.println(s);
    	}
    }

*  对于字符串相关的操作，如频繁的拼接、修改等，建议用 StringBulider，效率更高
 *  注意：如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用 String

**StringBuilder与StringBuffer**

*  StringBuffer 的用法与 StringBuilder 是一模一样的
 *  但 StringBuilder 是线程不安全的，StringBuffer 是线程安全的

### StringJoiner ###

**什么是StringJoiner**

*  JDK8 开始才有的，跟 StringBuilder 一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的
 *  好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public StringJoiner(间隔符号)</code></td> 
   <td>创建一个 StringJoiner 对象，指定拼接时的间隔符号</td> 
  </tr> 
  <tr> 
   <td><code>public StringJoiner(间隔符号, 开始符号, 结束符号)</code></td> 
   <td>创建一个 StringJoiner 对象，指定拼接时的间隔符号、开始符号和结束符号</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public StringJoiner add(添加的内容)</code></td> 
   <td>添加数据，并返回对象本身</td> 
  </tr> 
  <tr> 
   <td><code>public int length()</code></td> 
   <td>返回长度（字符出现的个数）</td> 
  </tr> 
  <tr> 
   <td><code>public String toString()</code></td> 
   <td>返回一个字符串（该字符串就是拼接之后的结果）</td> 
  </tr> 
 </tbody> 
</table>

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[Java]: https://blog.csdn.net/weixin_62511863/category_12365679.html?spm=1001.2014.3001.5482
[9cc17cdc1e314c0e89ac94844c94c897.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/36cfe3e5c39d4fd8a6771017de7f7352.png