【java核心技术】内部类与lambda表达式

最新推荐文章于 2025-08-14 17:02:37 发布

原创最新推荐文章于 2025-08-14 17:02:37 发布 · 172 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #lambda

java核心技术专栏收录该内容

17 篇文章

订阅专栏

本文深入解析Java内部类（成员内部类、局部内部类、匿名内部类）的特点与使用方法，并通过示例代码展示如何在实际编程中应用。同时，详细介绍了Lambda表达式的使用前提、不同参数与返回值情况下的语法格式，以及如何简化Lambda表达式和使用方法引用。

一、内部类

内部类：定义在一个类内部的类。编译器将内部类翻译为 Outer$Inner.class
分为：

成员内部类
局部内部类（匿名内部类）

关于访问修饰符：

外部类：public / (default)
成员内部类：public / protected / (default) / private
局部内部类：什么都不写

（1）成员内部类

两种调用方法：

外部类 . 内部类对象名 = new 外部类() . new内部类()
外部类方法调用内部类

代码示例：

public class Outer {
	private int num = 10;
	
	// 成员内部类
	public class Inner {
		private int num = 20;
		public void getNum() {
			int num = 30;
			// 调用同名变量
			System.out.println(num); // 30 
			System.out.println(this.num); // 20
			System.out.println(Outer.this.num); // 10
		}
		}
	// 外部类方法调用内部类
	public void call() {
		new Inner().getNum();
	}
	
	public static void main(String[] args) {
		// 调用内部类 方法一
		Outer.Inner inner = new Outer().new Inner();
		inner.getNum();
		
		// 调用内部类 方法二
		new Outer().call();
	}
}

（2）局部内部类

代码示例：

public class Outer {
	
	// 外部类方法
	public void getIn() {
		int num=100; // final
		
		// 局部内部类
		class Inner{
			public void getNum() {
				System.out.println(num);
			}
		}
		Inner inner = new Inner(); // 只能在当前方法中使用
		inner.getNum();
	}
	public static void main(String[] args) {
		Outer outer =new Outer();
		outer.getIn();
	}
	
}

（3）匿名内部类

只使用一次！！！的情况下才使用匿名内部类。若使用多次，还是需要单独定义实现类。
格式：接口名称对象名 = new 接口名称(){ };

public class InterfaceDemo {
	public static void main(String[] args) {
		Interface interface1= new Interface() {
		
			@Override
			public void getName() {
				System.out.println("这是匿名内部类");
			}
		};
		interface1.getName();
	}
}

二、lambda表达式

（1）使用lambda的前提

使用Lambda必须具有接口，且接口中有且仅有一个抽象方法。
使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

（2）无参数无返回值

代码示例：

public interface Interface {
	void getName();
}

public class InterfaceDemo {

	public static void printInterface(Interface interface1) {
		interface1.getName();
	}
		
	public static void main(String[] args) {
		/**
		 * 匿名内部类
		 */
		printInterface(new Interface() {
			
			@Override
			public void getName() {
				System.out.println("匿名内部类");	
			}
		});
		
		/** 
		 *  lambda表达式
		 */
		printInterface(()->{System.out.println("lambda");});
		
		/**
		 * 简化的lambda表达式
		 */
		printInterface(()->System.out.println("简化的lambda"));
		
	}
}

（3）有参数有返回值

按降序排列数组

import java.util.Arrays;
import java.util.Comparator;

public class Person {
	private String name;
	private int num;
	
	public Person() {
	}
	public Person(String name, int num) {
		this.name = name;
		this.num = num;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", num=" + num + "]";
	}
	
	
	public static void main(String[] args) {
		Person [] persons = {
				new Person("a",10),
				new Person("b",20),
				new Person("c",30)
		};
		
		/**
		 * 匿名内部类
		 */
		Arrays.sort(persons, new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				return o2.getNum()-o1.getNum();
			}
		});;
		
		/**
		 * lambda表达式
		 */
		Arrays.sort(persons, (Person o1,Person o2)->{return o2.getNum()-o1.getNum();});
		
		/**
		 * 简化的lambda表达式
		 */
		Arrays.sort(persons, (o1,o2)->o2.getNum()-o1.getNum());
		
		// 遍历数组
		for (Person person : persons) {
			System.out.println(person);
		}
		
	}
}

两数相加

public interface Interface {
	int add(int a ,int b);
}

public class InterfaceDemo {
	public static void addTO(int a ,int b,Interface interface1) {
		int result=interface1.add(a, b);
		System.out.println(result);
	}

	public static void main(String[] args) {
		/**
		 * 匿名内部类
		 */
		addTO(10, 20, new Interface() {
			
			@Override
			public int add(int a, int b) {
				return a+b;
			}
		});
		/**
		 * lambda表达式
		 */
		addTO(10, 20, (int a,int b)->{return a+b;});
		
		/**
		 * 简化的lambda表达式
		 */
		addTO(10, 20, (a,b)->a+b);
	}
}