内部类、函数式编程 - Java基础知识 18

最新推荐文章于 2021-11-17 12:15:11 发布

梦世

最新推荐文章于 2021-11-17 12:15:11 发布

阅读量301

点赞数 1

分类专栏： # Java基础知识

本文链接：https://blog.csdn.net/qq_34949782/article/details/106053371

版权

Java基础知识专栏收录该内容

20 篇文章 1 订阅

订阅专栏

学习笔记

内部类

虽然在类之中的基本组成是成员属性和方法，但是在任何的语言结构中也是允许进行嵌套的，所以在一个类的内部定义其它的类，被称为内部类。

内部类的基本定义

如果说内部类，其本身是一个独立且完善的类结构，在一个类的内部，除了属性与方法外可以使用class定义内部类。

范例：内部类的定义


class Outer{ // 外部类
	private String msg = "57" ; // 私有成员属性
	public void fun(){  // 普通方法
		Inner in = new Inner() ; // 实例化内部类对象
		in.print() ; // 调用内部类的方法
			
	}

	class Inner{ //在Outer之中定义内部类
		public void print(){
			System.out.println(Outer.this.msg) ; // msg是Outer类中的属性
		}
	}
	

}


public class JavaDemo{
	public static void main(String[] args){
		Outer out = new Outer() ; // 实例化外部对象
		out.fun() ; // 调用外部类的方法
	}
}

从整个代码上来看，内部类的结构并不难理解，甚至可以说其结构与普通类一样清晰。那么为什么提供内部类？

因为从整体的代码结构上讲内部类的结构并不合理，所以内部类本身最大的缺陷在于破环了程序的结构，但是破环需要有目的。那么优势在哪？

范例：将以上程序分为两个类


class Outer{
	private String msg = "57" ; // 私有成员属性
	public void fun(){  // 普通方法
		// 思考五：需要将当前对象Outer传递到Inner类之中
		Inner in = new Inner(this) ; 
		in.print() ;		
	}
	// 思考一：msg被外部访问的方法：getter
	public String getMsg(){
		return this.msg ;
	}

}

class Inner{ 
	// 思考三：Inner 这个对象实例化需要Outer类的引用
	private Outer out ;
	// 思考四：应该通过Inner类的构造方法获取Outter的对象
	public Inner(Outer out){
		this.out = out ;
	}
	public void print(){
		// 思考二：如果要调用外部类中的getter方法，那么需要有Outer类的对象
		System.out.println(out.getMsg()) ; 
	}
}
	
public class JavaDemo{
	public static void main(String[] args){
		Outer out = new Outer() ; // 实例化外部对象
		out.fun() ; // 调用外部类的方法
	}
}

可以发现这个的操作之中，主要的目的是将Inner这个内部类，可以访问Outer外部类中的私有属性。如果使用内部类的时候这个题的代码非常的麻烦，所以可以得出内部类的绝对优势：轻松的访问外部类中的私有属性。

内部类的相关说明

现在已经清楚内部类的定义和优势，现在对内部类进行相关说明，现在所定义的内部类是普通的内部类，不同普通的内部类往往会提供有属性和方法，需要注意的是，内部类虽然可以访问外部类中的私有属性或方法，同理，外部内也可以轻松访问内部类中的私有属性或方法。

范例：外部类访问内部类的私有成员和属性需要先实例化内部类


class Outer{ // 外部类
	private String msg = "57" ; // 私有成员属性
	public void fun(){  // 普通方法
		Inner in = new Inner() ; // 实例化内部类对象
		in.print() ; // 调用内部类的方法
		System.out.println(in.info) ; //访问内部类的私有属性
	}

	class Inner{ //在Outer之中定义内部类
		private String info = "加油" ;
		public void print(){
			System.out.println(Outer.this.msg) ; // msg是Outer类中的属性
		}
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Outer out = new Outer() ; // 实例化外部对象
		out.fun() ; // 调用外部类的方法
	}
}

使用内部类，内部类与外部类之间的私有操作的访问就不用通过setter或getter方法以及其它的间接方法。

但是需要注意的是内部类也是一个类，虽然在大部分情况下内部类是被外部类包裹的，但是外部类依然可以产生内部类的实例化对象，而此时内部类实例化对象的格式如下：

外部类.内部类内部类对象 = new 外部类().new 内部类() ;

在内部类编译完成之后会自动形成”Outer$Inner.class“文件，其中”$“这个符号换到程序之中就换为了”.“，所以内部类的全称是：”外部类.内部类“。内部类与外部类之间可以直接进行私有成员的访问，这样如果内部类有实例化对象了，就先保证外部类已经实例化了。

class Outer{ // 外部类
	private String msg = "57" ; // 私有成员属性
	class Inner{ //在Outer之中定义内部类
		private String info = "加油" ;
		public void print(){
			System.out.println(Outer.this.msg) ; // msg是Outer类中的属性
		}
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Outer.Inner in = new Outer().new Inner() ;
		in.print() ;
	}
}

如果Inner类只允许Outter类来使用，那么在这种情况下就可以使用private进行私有定义。

class Outer{ // 外部类
	private String msg = "57" ; // 私有成员属性
	private class Inner{ //在Outer之中定义内部类
		private String info = "加油" ;
		public void print(){
			System.out.println(Outer.this.msg) ; // msg是Outer类中的属性
		}
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Outer.Inner in = new Outer().new Inner() ;
		in.print() ;
	}
}

此时的Inner类无法在外部进行使用。

在Java之中作为最基础的结构体，实际上还有与之类似的抽象类或者接口，抽象类与接口中也可以定义内部结构。

范例：定义内部接口


interface IChannel{ // 定义接口
	public abstract void sendMessage(IMessage msg) ; // 发送消息
	interface IMessage { // 内部接口
		public abstract String getContent() ; // 获取消息内容 
	}
}

class ChannelImpl implements IChannel {
	public void sendMessage(IMessage msg) {
		System.out.println("发送消息：" + msg.getContent() ) ;
	}

	class MessageImpl implements IMessage {
		public String getContent(){
			return "57" ;
		}
	}
}


public class JavaDemo{
	public static void main(String[] args){
		IChannel channel = new ChannelImpl() ; 
		channel.sendMessage( ((ChannelImpl)channel).new MessageImpl()) ;
	}
}

下面继续观察一个内部抽象类，内部抽象类可以定义在普通类、抽象类、接口内部也是可以的。

范例：观察内部抽象类


interface IChannel{ // 定义接口
	public abstract void send() ; // 发送消息
	abstract class AbstractMessage{
		public abstract String getContent() ;
	}

}

class ChannelImpl implements IChannel {
	public void send(){
		AbstractMessage msg = new MessageImpl() ;
		System.out.println(msg.getContent()) ;
	}
	class MessageImpl extends AbstractMessage {
		public String getContent(){
			return "57" ;
		}
	}

}


public class JavaDemo{
	public static void main(String[] args){
		IChannel channel = new ChannelImpl() ; 
		channel.send() ;
	}
}

内部类还有一些一些更为有意思的结构，即：如果现在定义了一个接口，那么可以在内部利用类是实现该接口，在JDK中追加了static方法可以不受到实例化对象的控制，现在就可以利用此特性完成功能。

范例：接口内部进行接口实现

interface IChannel{ // 定义接口
	public abstract void send() ; // 发送消息
	class ChannelImpl implements IChannel{
		public void send() {
			System.out.println("57") ;
		}
	}
	public static IChannel getInstance() {
		return new ChannelImpl() ;
	}

}


public class JavaDemo{
	public static void main(String[] args){
		IChannel channel = IChannel.getInstance(); 
		channel.send() ;
	}
}

内部类这个结构是一种非常灵活的结构，只要你的语法满足了各种需求帮你实现。

static定义内部类

如果说现在在内部类上使用了static定义，那么这个类就变为了”外部类“，static定义的都是独立于类结构的，所以该类结构相当于是一个独立的程序类了。static不管定义的是类还是方法只能访问static成员，所以static定义的内部类只能够访问外部类中的属性或方法。

范例：使用static定义内部类

class Outer{
	private static final String MSG = "57" ;
	static class Inner {
		public void print(){
			System.out.println(Outer.MSG) ;
		}
	}
}

public class JavaDemo{
	public static void main(String[] args){

	}
}

这个时候的Inner类是一个独立的类，如果此时要想实例化Inner类对象，只需要根据”外部类.内部类“的结构实例化对象即可，格式如下：

外部类.内部类内部类对象 = new 外部类.内部类() ;

这个时候的类名称带有"."；

范例：实例化static内部类对象

class Outer{
	private static final String MSG = "57" ;
	static class Inner {
		public void print(){
			System.out.println(Outer.MSG) ;
		}
	}
}

public class JavaDemo{
	public static void main(String[] args){
		Outer.Inner in = new Outer.Inner() ;
		in.print() ;
	}
}

以后在开发之中，如果发现类名称上提供有”.“，首先应该立刻想到这是一个内部类的结构，如果可以直接进行实例化，应该立刻认识到这是一个static定义的内部类。

如果以static定义内部类的形式来讲并不常用，static定义内部接口的形式最为常用。

范例：使用static定义内部接口


interface IMessageWarp{ // 消息包装
	static interface IMessage {
		public String getContent() ;
	}
	static interface IChannel {
		public boolean connect() ; // 消息发送的通道
	}
	public static void send(IMessage msg, IChannel channel) {
		if (channel.connect()) {
			System.out.println(msg.getContent()) ;
		} else {
			System.out.println("消息通道无法建立，消息无法发送") ;
		}
	} 
}

class DefaultMessage implements IMessageWarp.IMessage {
	public String getContent() {
		return "57" ;
	}
}

class NetChannel implements IMessageWarp.IChannel {
	public boolean connect() {
		return true ;
	}
}


public class JavaDemo{
	public static void main(String[] args){
		IMessageWarp.send(new DefaultMessage(), new NetChannel() ) ;
	}
}

之所以使用static定义内部接口，主要是因为这些操作是属于一组相关的定义，有了外部接口之后更加明确的描述这些接口的主要功能。出现比较多。

方法中定义内部类

内部类可以在任意的结构中进行定义，这就包括了：类中、方法中、代码块中，但是总是实际开发来讲在方法中定义内部类的形式较多。

范例：观察在方法中定义的内部类

class Outer {
	private String msg = "57" ;
	public void fun(long time) {

		class Inner	{ // 内部类
			public void print() {
				System.out.println(Outer.this.msg) ;
				System.out.println(time) ;

			}
		}

		new Inner().print() ; // 方法中直接实例化内部类对象
	}
}


public class JavaDemo{
	public static void main(String[] args){
		new Outer().fun(54512) ;
	}
}

此时在fun()方法内部提供有Inner内部类的定义，并且可以发现内部类可以直接访问外部类中的私有属性，也可以直接访问方法中的参数，但是对于方法中的参数访问是从JDK1.8开始支持的，而在JDK1.8之前如果方法中定义内部类要想访问方法中的参数则参数前必须追加final。

范例：JDK1.8以前的程序结构

class Outer {
	private String msg = "57" ;
	public void fun(final long time) {
		final String info = "加油！" ; 
		class Inner	{ // 内部类
			public void print() {
				System.out.println(Outer.this.msg) ;
				System.out.println(time) ;
				System.out.println(info) ;

			}
		}

		new Inner().print() ; // 方法中直接实例化内部类对象
	}
}


public class JavaDemo{
	public static void main(String[] args){
		new Outer().fun(54512) ;
	}
}

之所以取消这样的限制，主要是为了其扩展的函数式编程准备的功能。

匿名内部类

匿名内部类是一种简化的内部类的处理形式，其主要是在抽象类和接口的子类上使用的。

范例：观察一个基本的程序结构


interface IMessage{
	public void send(String str) ;
}

class MessageImpl implements IMessage {
	public void send(String str) {
		System.out.println(str) ;
	}
}

public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = new MessageImpl() ;
		msg.send("57") ;
	}
}

如果说现在IMessage接口中的MessageImpl子类只是用唯一的一次，那么是否还有必要将其定义为单独的类。在这样的情况下，定义的子类是有些多余了，所以就可以利用匿名内部类的形式解决此问题。

范例：使用匿名内部类

interface IMessage{
	public void send(String str) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = new IMessage(){ // 匿名内部类
			public void send(String str) {
				System.out.println(str) ;
			}
		} ;
		msg.send("57") ;
	}
}

有些时候为了更加方便的体现处匿名内部类的使用，往往可以利用静态的方法做一个内部匿名内部类实现。

范例：在接口中直接定以匿名内部类

interface IMessage{
	public void send(String str) ;
	public static IMessage getInstance() {
		return new IMessage(){
			public void send(String str){
				System.out.println(str) ;
			}
		} ;
	}

}
public class JavaDemo{
	public static void main(String[] args){
		IMessage.getInstance().send("57") ;
	}
}

与内部类相比匿名内部类只是一个没有名字的，只能够使用一次的，并且结构固定的一个操作。

函数式编程

从JDK1.8开始为了简化使用者的代码开发，专门提供Lambda表达式的支持，利用此操作形式可以实现函数式的编程。对于函数式比较著名的语言：haskell、Scala，利用函数式编程可以避免面向对象编程之中的繁琐的处理问题。

面向对象在藏起发展过程之中一直有一部分的反对者，这些反对者认为面向对象的设计过于复杂了，并且过于繁琐了。以下面程序为例。

interface IMessage{
	public void send(String str) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = new IMessage(){
			public void send(String str){
				System.out.println("消息发送：" + str) ;
			}
		} ;

		msg.send("57") ;
	}
}

在这个程序里面核心的功能只有一行语句：”System.out.println("消息发送：" + str) ;“，但是为了这行语句依然按照完整的面向对象给出的设计结构进行开发。于是这些问题随着技术不断发展越来越突出了。

范例：使用Lambda实现与之前完全相同的功能

interface IMessage{
	public void send(String str) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = (str)->{
			System.out.println("发送消息：" + str) ;
		} ;
		msg.send("57") ;
	}
}

现在整个程序里面会发现只是编写了一行语句，于是利用这种形式就避免了复杂的面向对象结构化的要求。

Lambda表达式如果要想使用，有一个重要的要求：满足SAM(Single Abstract Method)标准，只有一个抽象方法，以IMessage接口为例，在这个接口里面只是提供了一个send()的方法，除此之外没有任何的其它方法定义，所以这样的接口被称为函数式接口，而只有函数式的接口才可以被Lambda表达式所使用。

范例：使用函数式接口注解

@FunctionalInterface // 函数式接口
interface IMessage{
	public void send(String str) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = (str)->{
			System.out.println("发送消息：" + str) ;
		} ;
		msg.send("57") ;
	}
}

对于Lambda表达式而言，提供有如下几种格式：

方法没有参数：()->{} ;
方法有参数： (参数，参数)->{} ;
如果现在只有一行语句返回：(参数，参数)->语句；

范例：定义没有参数的方法

@FunctionalInterface // 函数式接口
interface IMessage{
	public void send() ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = ()->{
			System.out.println("发送消息：57") ;
		} ;
		msg.send() ;
	}
}

范例：定义有参数的处理形式

@FunctionalInterface // 函数式接口
interface IMessage{
	public void send() ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMessage msg = ()->{
			System.out.println("发送消息：57") ;
		} ;
		msg.send() ;
	}
}

以上的表达式之中会发现只有一行语句，这个时候也可以进一步简化。

范例：简化Lambda的操作

@FunctionalInterface // 函数式接口
interface IMath{
	public int add(int x, int y) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IMath msg = (t1, t2)->t1 + t2 ;
		System.out.println(msg.add(1,1)) ;
	}
}

利用Lambda表达式的确可以摆脱传统面向对象之中关于结构的限制，使得代码结构更加简便。

方法引用

引用数据类型最大的一个特点是可以进行内存的指向处理，但是在传统的开发之中一直使用的只是对象引用操作，在JDK1.8之后也提供有方法的引用，即：不同的方法名称可以描述同一个方法。如果要进行方法的引用提供有以下四种形式：

引用静态方法：类名称 :: static方法名称；
引用某个实例对象的方法：实例化对象 :: 普通方法；
引用特定类型的方法：特定类 :: 普通方法；
引用构造方法：类名称 :: new 。

范例：引用静态方法

在String类中提供String.valueOf()方法，这个方法属于静态方法。

|- 方法定义: public static String valueOf(int i) ；该方法有参数，并且还有返回值。

@FunctionalInterface // 函数式接口
// P描述的是参数、R描述的是返回值
interface IFunction<P, R>{
	public R change(P p) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IFunction<Integer, String> fun = String :: valueOf ;
		String str = fun.change(100) ;
		System.out.println(str.length()) ;
	}
}

利用方法引用这一概念可以为一个方法定义多个名字，但是要求必须是函数式接口，即：函数式接口为一个方法定义多个名字，但是这里向上转型了，不能用fun.valueOf。

范例：引用实例化对象中的方法

在String类里面有一个转大写的方法；public String toUpperCase() ；

|- 这个方法必须是有实例化对象提供的情况下才能调用

@FunctionalInterface // 函数式接口
// P描述的是参数、R描述的是返回值
interface IFunction<R>{
	public R upper() ;
}
public class JavaDemo{
	public static void main(String[] args){
		IFunction< String> fun = "hello" :: toUpperCase ;
		System.out.println(fun.upper()) ;
	}
}

在进行方法引用的时候，也可以引用特定类中的一些操作方法，在String类中提供有一个字符串大小关系的比较。

比较大小：public int compareTo(String anotherString)

这个一个普通方法，如果要引用普通方法往往要实例化对象，但是现在你不想给相互实例化对象，只是想引用这个方法，则就可以使用特定类进行引用处理。

范例：引用指定类中的方法

@FunctionalInterface // 函数式接口
// P描述的是参数、R描述的是返回值
interface IFunction<P>{
	public int comper(P p1, P p2) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IFunction< String> fun = String :: compareTo ;
		System.out.println(fun.comper("A", "a")) ;
	}
}

在方法引用中，最具杀伤力的式构造方法的引用。

范例：引用构造方法

class Person {
	private String name ;
	private int age ;
	public Person(String name, int age) {
		this.name = name ;
		this.age = age ;
	}
	public String toString() {
		return "姓名：" + this.name + "、年龄：" + this.age ; 
	}
}
@FunctionalInterface // 函数式接口
interface IFunction<R>{
	public R creat(String s, int a) ;
}
public class JavaDemo{
	public static void main(String[] args){
		IFunction<Person> fun = Person :: new ;
		System.out.println(fun.creat("张三", 20)) ;
	}
}

提供方法引用的概念更多情况下也只是弥补了对于引用的支持功能。

内建函数式接口

在JDK1.8之中提供Lambda表达式，也提供方法引用，但是现在有开发者定义函数式的接口需要大量使用”@FuntionalInterface“注解进行申明，于是很多时候为了方便则可以使用系统定义的函数式接口。

在系统之中专门提供一个java.util.funtion的开发包。里面可以直接使用函数式接口，在这个包里面可以使用如下的几个核心接口：

1、功能型函数式接口：

在String类中有一个方法，判断是否有指定的字符串开头：public boolean startsWith(String str)

接口定义

接口使用

@FunctionalInterface
public interface Function<T,R>{
public R apply(T t)
}

import java.util.function.* ;
public class JavaDemo{
   public static void main(String[] args){
       Function<String, Boolean> fun ="**Hello" :: startsWith ;
       System.out.println(fun.apply("**")) ;

}
}

所以对于这种接收一个参数并且返回值为一个，就可以直接使用这个函数式接口。

2、消费型函数式接口：只能够进行数据的处理操作，而没有任何的返回。

在进行系统数据输出的时候使用的是：System.out.println() ;

接口定义	接口使用
`@FunctionalInterface public interface Consumer<T> { public void accept(T t) ; }`	import java.util.function.* ; public class JavaDemo{ public static void main(String[] args){ Consumer<String> con = System.out :: println ; con.accept("57") ; } }

3、供给型函数式接口：

在String类中提供有转小写的方法：public String toLowerCase()，这个方法没有接收参数，但是有返回值

接口定义 接口使用

@FunctionalInterface
public interface Supplier<T>{
   public T get() ;
}

import java.util.function.* ;
public class JavaDemo{
   public static void main(String[] args){
       Supplier<String> sup = "HELLO" :: toLowerCase ;
       System.out.println(sup.get()) ;

}
}

4、断言型函数式接口：进行判断处理

在String类中有一个equalsIgnoreCase() ;

接口定义

接口使用

@FunctionalInterface public interface Predicate<T>{

public boolean test(T t) ;

}

import java.util.function.* ;
public class JavaDemo{
   public static void main(String[] args){
       Predicate<String> pre = "Hello" :: equalsIgnoreCase ;
       System.out.println(pre.test("Hello")) ;

}
}

以后对于实际的开发之中，如果JDK提供的函数式接口可以被使用，就没有必要进行重新定义了。

梦世

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
内部类、函数式编程 - Java基础知识 18

目录内部类内部类的基本定义内部类的相关说明static定义内部类方法中定义内部类匿名内部类函数式编程方法引用内建函数式接口学习笔记内部类虽然在类之中的基本组成是成员属性和方法，但是在任何的语言结构中也是允许进行嵌套的，所以在一个类的内部定义其它的类，被称为内部类。内部类的基本定义如果说内部类，其本身是一个独立且完善的类结构，在一个类的内部，除了属性与方法外可以使用class定义内部类。范例：内部类的定义class Outer{ // 外部类
复制链接

扫一扫