北京手机网站开发,网站建设服务亿企网络,北京展览展示设计有限公司,重庆承越网站建设公司文章目录第六章 接口、lambda表达式与内部类接口接口的概念接口的属性接口与抽象类静态和私有方法默认方法解决默认方法冲突接口与回调Comparator接口对象克隆lambda表达式函数式接口方法引用构造器引用变量作用域处理lambda表达式再谈Comparator类内部类使用内部类访问对象的状…
文章目录第六章 接口、lambda表达式与内部类接口接口的概念接口的属性接口与抽象类静态和私有方法默认方法解决默认方法冲突接口与回调Comparator接口对象克隆lambda表达式函数式接口方法引用构造器引用变量作用域处理lambda表达式再谈Comparator类内部类使用内部类访问对象的状态局部内部类由外部方法访问变量匿名内部类静态内部类代理何时使用代理创建代理对象代理的特性第六章 接口、lambda表达式与内部类
接口: 描述类应该做什么, 不指定如何做lambda表达式: 表示使用回调或者可变行为的代码 接口
接口的概念 接口: 不是类, 而是对希望符合这个接口的类的一组需求 Arrays类中的sort方法对对象数组进行排序, 要求对象所属的内必须实现Comparable接口
public interface Comparable
{int compareTo(Object other);
}
//java5后
public interface ComparableT
{int compareTo(T other);
}接口中的所有方法自动为public接口中可以包含多个方法, 但是接口不会有实例字段让一个类实现一个接口: 将类声明为实现给定的接口对接口中的所有方法提供定义 将类声明为实现为某个接口, 使用关键字implements
class Employee implements ComparableJava API建议equals, compareTo方法兼容例外:x BigDecimal(1.0); y BigDecimal(1.00); x.equals(y)//false x.compareTo(y) 0
package chapter6_interface_lambda_innerClass.interfaces;public class Employee implements ComparableEmployee{private String name;private double salary;public Employee(String name, double salary) {this.name name;this.salary salary;}public double getSalary() {return salary;}public String getName() {return name;}public int compareTo(Employee other) {return Double.compare(salary, other.salary);}
}package chapter6_interface_lambda_innerClass.interfaces;import java.util.Arrays;public class EmployeeSortTest {public static void main(String[] args) {var staff new Employee[3];staff[0] new Employee(Oukunnan, 25598);staff[1] new Employee(Ovfdunnan, 18);staff[2] new Employee(dsukunnan, 98);Arrays.sort(staff);for (Employee employee : staff) {System.out.println(employee.getName() salary employee.getSalary());}}
} 接口的属性
接口不是类, 不能用new运算符实例化一个接口能够声明接口变量: Comparable x ; //OK接口变量必须引用实现了这个接口的类对象 x new Employee(...);instanceof: 1. 检查一个对象是否属于某个特定的类 2. 一个对象是否实现了某个特定的接口
if (anObject instanceof Comparable){...};与建立类的继承层次类似, 可以扩展接口
public interface Moveable{...}
public interface Powered extends Moveable{..}接口不能包含实例字段但是可以包含常量接口的方法总是public, 接口的字段总是public static final, 都可以省略, 建议省略每个类只有一个超类, 却可以实现多个接口, 有点像C的多重继承 接口与抽象类
抽象类问题: 每个类只能扩展一个类java可以扩展一个基类并且派生多个接口 静态和私有方法
标准库中成对出现的接口和实用工具类: Collection/Collections, Path/paths允许在接口中增加静态方法, 一般做法是放在伴随类中java9中接口中的方法可以是private 默认方法
接口方法提供一个默认实现, default修饰符标记
public interface ComparableT
{default int CompareTo(T other) {return 0;}
}如果迭代器是只读的就不用实现remove方法 public interface IteratorE
{boolean hasNext();E next();default void remove(){throw new UnsupprotedOperationException(remove);}
}另一个作用是接口演化, 实现源代码兼容 解决默认方法冲突
超类优先同时实现的两个接口中由完全同名并且参数类型相同的方法, 要求这个类实现该方法覆盖接口的方法class Student extends Person implements Named{...}只会考虑超类方法, 类优先原则 接口与回调
回调: 指定某个特定事件发生时应该采取的动作
package chapter6_interface_lambda_innerClass.timer;import java.awt.event.*;
import java.awt.*;
import java.time.*;
import javax.swing.*;public class TimerTest {public static void main(String[] args) {var listener new TimePrinter();var timer new Timer(1000, listener);//每隔1000ms(1s)响铃并且打应输出timer.start();JOptionPane.showMessageDialog(null, Quit Program?);//展示消息框System.exit(0);}
}class TimePrinter implements ActionListener {public void actionPerformed(ActionEvent event) {//ActionEvent 事件参数,提供事件的相关信息 //getWhen的得到纪元以来的毫秒数, 利用函数转换成可读时间System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));Toolkit.getDefaultToolkit().beep(); //调用默认工具箱响铃}
} Comparator接口
对于对象数组进行排序, 前提是这些对象是实现了Comparable接口类的实例如果按照长度而不是字典顺序对于字符串进行排序, 使用Arrays.sort的另一种版本, 一个数组和比较器作为参数比较器实现Comparator接口
public interface ComparatorT
{int compare(T first, T second);
}class LengthComparator implements ComparatorString
{public int compare(String first, String second){return first.length() - second.length();}
}调用
Arrays.sort(words, new LengthComparator());对象克隆
拷贝: 一个包含对象引用的变量建立副本时,原变量和副本都是对同一个对象的引用, 任何一个对象的引用都会改变另一个变量克隆: 希望变量是一个新的对象, 初始状态和原变量相同, 之后会有各自不同的状态默认的克隆操作是浅拷贝: 逐个字段拷贝, 对于数值和其他基本类型克隆, 但是对于包含对象引用的子对象也会共享一些信息如果原对象和浅克隆对象共享的子对象是不可变的, 那么浅拷贝的共享安全深拷贝: 子对象可变的, 必须重新定义clone方法建立深拷贝, 克隆所有对象Cloneable: 标记接口, 不包含任何方法(一般的接口确保一个类实现一组特定的方法), 作用:允许类型查询中使用instanceof
if(obj instanceof Cloneable) ...所有数组类型都有一个公共的clone方法, 不是受保护的
int[] a {1, 2, 3};
int[] b a.clone();
b[0] 5;// a[0] 1;package chapter6_interface_lambda_innerClass.clone;public class CloneTest {public static void main(String[] args) throws CloneNotSupportedException{var original new Employee(Ou Kunnan, 52000);original.setHireDay(2001, 12, 26);Employee copy original.clone();System.out.println(copy); // 自动调用toString方法,相当于copy.toString()copy.raiseSalary(10);copy.setHireDay(2002, 12, 26);System.out.println(original: original);System.out.println(copy: copy);}
}package chapter6_interface_lambda_innerClass.clone;import java.util.Date;
import java.util.GregorianCalendar;public class Employee implements Cloneable{private double salary;private String name;private Date hireDay;public Employee(String name, double salary) {this.name name;this.salary salary;hireDay new Date();}public Employee clone() throws CloneNotSupportedException {Employee cloned (Employee) super.clone();cloned.hireDay (Date) hireDay.clone();return cloned;}public void setHireDay(int year, int month, int day) {Date newHireDay new GregorianCalendar(year, month - 1, day).getTime();hireDay.setTime(newHireDay.getTime());}public void raiseSalary(double byPercent) {double raise salary * byPercent / 100;salary raise;}public String toString() {return Employee[name name , salary salary , hireDay hireDay ];}
} lambda表达式 lambda表达式就是一个代码块,以及必须传入的代码变量规范 形式: 参数, -, 一个表达式 (String first, String second)-{if(first.length() second.length()) return -1;else return 1;
}lambda没有参数,()- {…}; 如果可以推导出lambda表达式参数类型, 可以忽略其类型
ComparatorString comp (first, second) - first.length() - second.length();只有一个参数并且类型可以推到, 可以省略小括号 无需指定返回类型
package chapter6_interface_lambda_innerClass.lambda;import java.util.*;import javax.swing.*;
import javax.swing.Timer;public class lambdaTest {public static void main(String[] args) {var planets new String[]{Mercury, Venus, Earth, Mars,Jupiter, Saturn, Uranus, Neptune};System.out.println(Arrays.toString(planets));System.out.println(Sorted in dictionary order:);Arrays.sort(planets);System.out.println(Arrays.toString(planets));System.out.println(Sorted by length:);Arrays.sort(planets, (first, second) - first.length() - second.length());//第二个参数应该是比较器System.out.println(Arrays.toString(planets));var timer new Timer(1000, event - System.out.println(The time is new Date()));timer.start();JOptionPane.showMessageDialog(null, quit?);System.exit(0);}
} 函数式接口
函数式接口: 对于只有一个抽象方法的接口,需要这种接口对象时, 可以提供一个lambda表达式lambda表达式可以转换为接口
var timer new Timer(1000, event-{System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));Toolkit.getDefaultToolkit().beep(); })ArrayList类的removeIf方法参数是Predicate
public interface PredicateT
{boolean test(T t);
}
//删除列表所有null值
list.removeIf(e - e null);supplier没有参数, 调用时会生成T类型的值, 用于实现懒计算
public interface SupplierT
{T get();
}LocalDate hireDay Objects.requireNonNullOrElse(day, new LocalDate(1970, 1, 1));//通过使用供应者supplier, 延迟该计算 , 只有daynull时候才调用供应者(构造默认的LocalDate)
LocalDate hireDay Objects.requireNonNullOrElse(day, () - new LocalDate(1970, 1, 1));方法引用 var timer new Timer(1000, event-System.out.println(event));
var timer new Timer(1000, System.out::println);System.out::println是一个方法引用, 它指示编译器生成一个函数式接口的实例,覆盖这个接口的抽象方法来调用给定的方法 上面的例子, 会生成一个ActionListener, 他的actionPerformed(ActionEvent e)方法要调用System.out.println(e) 方法引用不是对象, 为一个类型为函数式接口的变量赋值时会生成一个对象 方法引用示例与等价的lambda表达式见P248 当lambda表达式的体只调用一个方法而不做其他操作的时候才能把方法引用重写为方法引用 构造器引用
Person::new就是Person构造器的一个引用int[]::new是一个构造器引用, 他有一个参数,即数组的长度, 等价于x-new int[x] 变量作用域
lambda表达式三个部分: 代码块, 参数, 自由变量的值可以把一个lambda表达式转换为一个包含方法的对象, 自由变量的值会复制到这个对象的实例变量中lambda表达式是闭包的lambda表达式可以捕获外围作用域中变量的值, 确保值是明确定义的(事实最终变量, 初始化后不会改变) 处理lambda表达式 lambda表达式重点是延迟执行 Runnable作为无参数或返回值的动作运行, action.run()会调用lambda表达式主体 package test;import java.util.function.IntConsumer;public class lambda {public static void main(String[] args){repeat(10, ()-System.out.println(hello, world));repeat(10, (i)-System.out.println(Countdown: (9-i)));}public static void repeat(int n, Runnable action){for(int i 0; i n; i) action.run();}public static void repeat(int n, IntConsumer action) {for(int i 0; i n; i)action.accept(i);}
}再谈Comparator类
P255 内部类
定义在另一个类中的类内部类可以对同一个包中的其他类隐藏, 内部类方法可以访问定义这个类的作用域中的数据,包括原本的私有数据 使用内部类访问对象的状态
一个内部类方法可以访问自身的数据字段,也可以访问创建它的外围类对象的数据字段内部类对象总有一个隐式引用指向创建它的外部类对象这个引用在构造器中设置, 编译器会修改所有内部类的构造器,添加一个对应外围类引用的参数
以下这个例子生成的无参数构造器如下
public TimePrinter(TalkingClock clock){outer clock;}package chapter6_interface_lambda_innerClass.innerClass;
import java.awt.*;
import java.awt.event.*;
import java.time.*;import javax.swing.*;public class innerClassTest {public static void main(String[] args) {var clock new TalkingClock(1000, true);clock.start();JOptionPane.showMessageDialog(null, Quit?);System.exit(0);}
}class TalkingClock{private int interval;private boolean beep;public TalkingClock(int interval, boolean beep) {this.interval interval;this.beep beep;}public void start() {var listener new TimerPrinter();var timer new Timer(interval, listener);timer.start();}public class TimerPrinter implements ActionListener {public void actionPerformed(ActionEvent event) {System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));if (beep) {Toolkit.getDefaultToolkit().beep();}}}}局部内部类 TimePrinter名字只出现了一次,在start方法中创建这个类型对象时使用了一次.可以在一个方法中局部定义这个类 public void start() {class TimerPrinter implements ActionListener {public void actionPerformed(ActionEvent event) {System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));if (beep) {Toolkit.getDefaultToolkit().beep();}}}var listener new TimerPrinter();var timer new Timer(interval, listener);timer.start();
}局部内部类声明时候不能有访问修饰符public, private 优势: 对外部完全隐藏,除了start代码 由外部方法访问变量 局部内部类不仅能够访问外部类字段,还可以访问局部变量(事实最终变量) public void start(int interval, boolean beep) {class TimerPrinter implements ActionListener {public void actionPerformed(ActionEvent event) {System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));if (beep) {Toolkit.getDefaultToolkit().beep();}}}var listener new TimerPrinter();var timer new Timer(interval, listener);timer.start();
}匿名内部类 匿名内部类不需要为类指定名字 以下代码: 创建了一个类的新对象,这个类实现了ActionListener接口, 需要实现的方法{}中定义 public void start(int interval, boolean beep) {var listener new ActionListener();{public void actionPerformed(ActionEvent event) {System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));if (beep) {Toolkit.getDefaultToolkit().beep();}}};var timer new Timer(interval, listener);timer.start();
}//用lambda表达式
public void start(int interval boolean beep)
{var timer new Timer(interval, event-{System.out.println(At this tone, the time is Instant.ofEpochMilli(event.getWhen()));if (beep) Toolkit.getDefaultToolkit().beep();})
}语法如下
new SuperType(construction parameters)
{innner class methods and data
}SuperType可以是接口,内部类就要实现这个接口;如果是一个类,内部类就要扩展这个类
构造器名字必须和类名相同,匿名内部类没有类名所以没有构造器构造参数要传递给超类构造器注意: 构造一个类的新对象和构造一个扩展了那个类的匿名内部类的对象之间的差别
vae queen new Person(Marry);
var count new Person(bjcs){...};匿名内部类不能有构造器但是可以提供一个对象的 双括号初始化: var f new ArrayListString();
f.add(Harry);
f.add(Alice);
invite(f);
---
invite(new ArrayListString)(){{add(Harry); add(Alice);}}
//外层括号建立了一个匿名子类,内层括号是一个初始化块得到匿名内部类的外部类类名不能直接getClass,这个方法带调用this.getClass(), 静态方法没有隐式参数
new Object(){}.getClass().getEnclosingClass()new Object()建立Object的匿名子类的一个匿名对象,getEnclosingClass则得到其外围类,也就是包含这个静态方法的类 静态内部类
只要内部类不需要访问外围类对象,就应该使用静态内部类接口中声明的内部类自动为public, static
package chapter6_interface_lambda_innerClass.staticInnerClass;public class StaticInnerClassTest
{public static void main(String[] args){var values new double[20];for (int i 0; i values.length; i)values[i] 100 * Math.random();ArrayAlg.Pair p ArrayAlg.minmax(values);System.out.println(min p.getFirst());System.out.println(max p.getSecond());}
}class ArrayAlg{public static class Pair {/* 一个静态的内部类 */private double first;private double second;/*** Constructs a pair from two floating-point numbers** param f the first number* param s the second number*/public Pair(double f, double s) {first f;second s;}/*** Returns the first number of the pair** return the first number*/public double getFirst() {return first;}/*** Returns the second number of the pair** return the second number*/public double getSecond() {return second;}}/*** Computes both the minimum and the maximum of an array* param values an array of floating-point numbers* return a pair whose first element is the minimum and whose second element* is the maximum*/public static Pair minmax(double[] values){double min Double.POSITIVE_INFINITY;double max Double.NEGATIVE_INFINITY;for (double v : values) {if (min v) {min v;}if (max v) {max v;}}return new Pair(min, max);}
}代理
何时使用代理
代理类在运行时闯将全新的类,这样代理类可以实现你指定的接口代理类包含的方法: 指定接口所需要的全部方法, Object类中的全部方法(equals, toStirng等) 创建代理对象
需要使用Proxy类的newProxyInstance方法, 有三个参数 一个类加载器(这里指定系统类加载器)一个Class对象数组,每个元素对应需要实现的各个接口一个调用处理器 代理作用: 将方法调用路由到远程服务器;在运行中的程序将用户界面事件与动作关联起来;为了调试,跟踪方法使用
package chapter6_interface_lambda_innerClass.proxy;import java.lang.reflect.*;
import java.util.*;public class ProxyTest
{public static void main(String[] args) {var elements new Object[1000];for (int i 0; i elements.length; i) {Integer value i 1;var handler new TraceHandler(value);Object proxy Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Comparable.class}, handler);elements[i] proxy;}Integer key new Random().nextInt(elements.length) 1;int result Arrays.binarySearch(elements, key);if(result 0) System.out.println(elements[result]);}
}class TraceHandler implements InvocationHandler {//打应输出方法名和参数,并且调用该方法private Object target;public TraceHandler(Object t) {target t;}public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {System.out.print(target);System.out.print(. m.getName() ();if (args ! null) {for (int i 0; i args.length; i) {System.out.print(args[i]);if(i args.length - 1) System.out.print(, );}}System.out.println());return m.invoke(target, args);}
}代理的特性
代理是在运行过程中创建的,一旦创建就变成了常规类代理类都是扩展Proxy, 一个代理类只有一个实例字段即调用处理器,在超类Proxy中定义所有的代理类都要覆盖toString, hasCode, equals方法, 这些方法只是在调用处理器上调用invoke.
