当前位置：首页 > news >正文

Java基础（代码块，内部类，函数式编程，常用API，GUI编程）

news 2026/3/27 4:07:23

Java基础（代码块，内部类，函数式编程，常用API，GUI编程）

代码块

静态代码块：
- static
- 类加载时自动执行，由于类只会执行一次，所有静态代码块也只会执行一次
- 完成类的静态资源初始化
- 比main方法先加载。
实例代码块：
- 每次创建对象时，执行实例代码块，并在构造器前执行
- 和构造器一样，都是用来完成对象的初始化。

内部类（一个类定义在另一个类的内部）

成员内部类(外部类对象持有)
- 格式：外部类名称.内部类名称对象名 = new 外部类名称（）.new 内部类名称（）;
  
  public class Outer{
  
  public class Inner{
  
  }
  
  }
- 创建对象：Outer.Inner oi = new Outer( ).new Inner( );
- 成员内部类可以直接访问外部类的静态成员和实例成员
- 成员内部类的实例方法中可以直接拿到外部类的对象，外部类名称.this。
```
Outer{ a=100;Inner{a=80;public void show(){a=200;System.out.println(a);//200System.out.println(this.a);//80System.out.println(Outer.this.a);//100}} }
```
静态内部类(外部类本身持有)
- public class Outer{
  
  public static class Inner{
  
  }
  
  }
- 创建对象：Outer.Inner oi = new Outer. Inner( );
- 可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
局部内部类
- 定义在，方法，代码块，构造器等执行体中。
匿名内部类（重点）
- 匿名内部类实际是有名字的：外部类名$编号.class
- 匿名内部类本质是一个子类，同时会立即构建一个子类对象
```
class Test {public static void main(String[] args) {//这是一个匿名内部类(其实际名字为Test$1)Animal a=new Animal(){@Overridepublic void cry(){System.out.println("喵喵喵");}}a.cry();}
}
abstract class Animal{public abstract void cry();
}
```
- 开发中不是我们主动写匿名内部类，而是用别人功能的时候，别人让我们写一个匿名内部类，我们才会写。
- 可以简化代码，简化规则为：
  - 参数类型可以全部省略不写
  - 如果只有一个参数，参数类型省略的同时，“（）”也可以省略，但多个参数不能省略“（）”。
  - 如果Lambda表达式中只有一行代码，大括号可以不写，同时要省略分号“ ；”，如果是return 语句，也必须去掉return。

函数式编程(使用Lambda替代某些匿名内部类，使程序代码更简洁)

Lambda
- （x）->2x+1。
- 替代某些内部类，使程序更简洁。
- Lambda并不是可以简化全部的匿名内部类，Lambda只能简化函数式接口的匿名内部类。其中函数式接口指的是有且只有一个抽象方法的接口。（来源于接口，只有一个抽象方法）
```
class Test {public static void main(String[] args) {Animal a=()->System.out.println("喵喵喵");a.cry();}
}
//定义函数式接口
@FunctionalInterface//声明函数式接口的注解
interface Animal{void cry();
}
```

举一个学生例

import java.util.Arrays;
import java.util.Comparator;public class test {public static void main(String[] args) {Student[] student=new Student[3];student[0]=new Student("qq",12);student[1]=new Student("ww",55);student[2]=new Student("ff",34);//对学生年龄进行升序排序Arrays.sort(student,new Comparator<Student>(){@Overridepublic int compare(Student o1,Student o2){return o1.getAge()-o2.getAge();}});//是上面代码的简化Arrays.sort(student, (o1,o2)->o1.getAge()-o2.getAge() );}
}

方法引用
- 简化Lambda
- 静态方法引用：如果某个Lambda表达式里只是调用一个静态方法，并且“->”前后参数形式一致，就可以使用静态方法引用。

import java.util.Arrays;
import java.util.Comparator;public class test {public static void main(String[] args) {Student[] student=new Student[3];student[0]=new Student("qq",12);student[1]=new Student("ww",55);student[2]=new Student("ff",34);   //对学生年龄进行升序排序Arrays.sort(student,new Comparator<Student>(){@Overridepublic int compare(Student o1,Student o2){return o1.getAge()-o2.getAge();}});//是上面代码的简化Arrays.sort(student, (o1,o2)->o1.getAge()-o2.getAge() );//这是使用静态方法引用后的最简形式（Lambda表达式中只调用这一个静态方法）//类名 :: 静态方法名Arrays.sort(student, Student::Compare);}
}//学生类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {private String name;private int age;//一个静态方法public static int Compare(Student o1, Student o2) {return o1.getAge()- o2.getAge();}}

实例方法引用：
- 如果某个Lambda表达式里只是通过对象名称调用一个实例方法，并且“->”前后参数形式一致，就可以使用实例方法引用。

import java.util.Arrays;
import java.util.Comparator;public class test {public static void main(String[] args) {Student[] student=new Student[3];student[0]=new Student("qq",12);student[1]=new Student("ww",55);student[2]=new Student("ff",34);   //对学生年龄进行升序排序Arrays.sort(student,new Comparator<Student>(){@Overridepublic int compare(Student o1,Student o2){return o1.getAge()-o2.getAge();}});//是上面代码的简化Arrays.sort(student, (o1,o2)->o1.getAge()-o2.getAge() );//这是使用静态方法引用后的最简形式（Lambda表达式中只调用这一个静态方法）//类名 :: 静态方法名Arrays.sort(student, Student::Compare);//生成Student学生对象，用对象来调用实例方法Student s=new Student();//对象名::实例方法名Arrays.sort(student, s::compareByHeight);//按学生身高来排序}
}//学生类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {private String name;private int age;//一个静态方法public static int Compare(Student o1, Student o2) {return o1.getAge()- o2.getAge();}//实例方法public int compareByHeight(Student o1, Student o2) {使用了Double的方法return Double.compare(o1.getHeight()-o2.getHeight(), o2.getHeight());}
}

特定类型方法引用: 类型名称：：方法名

public class test {public static void main(String[] args) {//举例：给一堆字符串数组元素，忽略大小写，对字母进行比较，其中使用了compareToIgnoreCase方法//Arrays.sort(数组名,String(主调参数的数据类型)::compareToIgnoreCase);}
}

构造器引用
- 如果某个Lambda表达式里只是在创建对象，并且“->”前后参数情况一致，就可以使用构造器引用。
- 类名：：new
```
//举例：
CarFactory cf = name->new Car(name);
//可简化为：
CarFactory cf = Car::new;//构造器引用
```

常用API

String 创建对象的区别
- 以String s = "........."的形式创建的字符串对象会存储到堆中的字符串常量池，且相同内容只存储一份。（节约内存）
- 以String s = new String( )形式创建的字符串对象，每new一次都会产生一个新的对象放在内存堆中。

String s1="abc";
String s2="abc";
System.out.println(s1==s2);//trueString s3=new String("abc");
String s4=new String("abc");
System.out.println(s3==s4);//false