JavaSE部分——面向对象（下）
面向对象（下）
一、Java 8 增强的包装类
为了解决8种基本数据类型的变量不能当成Object类型变量使用的问题，Java提供了包装类（Wrapper Class）的概念，为8种基本数据类型分别定义了相应的引用类型，并称之为基本数据类型的包装类。
- 自动装箱：把一个基本类型变量直接赋给对应的包装类变量，或者赋给Object变量（Object是所有类的父类，子类对象可以直接赋给父类变量）
- 自动拆箱：允许直接把包装类对象直接赋给一个对应的基本类型变量
把字符串类型的值转换为基本类型的值有两种方式
- 利用包装类提供的parseXxx(String s)静态方法(除 Character 之外的所有包装类都提供了该方法)
- 利用包装类提供的valueOf(String s)静态方法
- String类也提供了多个重载valueOf()方法，用于将基本类型变量转换成字符串
代码示例
public class Primitive2String {
public static void main(String[] args) {
String intStr = "123";
// 把一个特定字符串转换成int变量
int it1 = Integer.parseInt(intStr);
int it2 = Integer.valueOf(intStr);
System.out.println(it2);
String floatStr = "4.56";
// 把一个特定字符串转换成float变量
float ft1 = Float.parseFloat(floatStr);
float ft2 = Float.valueOf(floatStr);
System.out.println(ft2);
// 把一个float变量转换成String变量
String ftStr = String.valueOf(2.345f);
System.out.println(ftStr);
// 把一个double变量转换成String变量
String dbStr = String.valueOf(2.344);
System.out.println(dbStr);
// 把一个boolean变量转换成String变量
String boolStr = String.valueOf(true);
System.out.println(boolStr);
}
}
基本类型变量和""进行连接运算，系统会自动把基本类型变量转换成字符串
//intStr的值为"5" String intStr = 5 + "";
比较两个基本类型值的大小——静态的compare(xxx val1,xxx val2)
- static String toUnsignedString(int/long i):int或long型整数转换为无符号整数对应的字符串
- static String toUnsignedString(int/long i,int radix):int或long型整数转换为指定进制的无符号整数对应的字符串
- static xxx oarseUnsignedXxx(String s):指定字符串解析成无符号整数
- static xxx parseUnsignedXxx(String s,int radix):指定字符串按指定进制解析成无符号整数
- static int compareUnsigned(xxx x,xxx y):将x、y两个整数转换为无符号整数后比较大小
- static long divideUnsigned(long dividend,long divisor):将x、y两个整数转换为无符号整数后计算他们相除的商
- static long remainderUnsigned(long dividend,long divisor):将x、y两个整数转换为无符号整数后计算他们相除的余数
二、处理对象
1、打印对象和toString方法
- Object类提供的toString()方法总是返回该对象实现类的"类名+@+hashCode"值
重写Object类的toString()方法
class Apple {
private String color;
private double weight;
public Apple() {
}
// 提供有参数的构造器
public Apple(String color, double weight) {
this.color = color;
this.weight = weight;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
// 重写toString()方法，用于实现Apple对象的“自我描述”
public String toString() {
return "一个苹果，颜色是: " + color + "，重量是: " + weight;
}
}
public class ToStringTest {
public static void main(String[] args) {
Apple a = new Apple("红色", 5.68);
// 打印Apple对象
System.out.println(a);
}
}2、==和equals方法
判断两个变量是否相等有两种方式
- ==运算符：如果两个变量是基本类型变量，且都是数据类型，则只要两个变量的值相等，就将返回true；对于两个引用类型变量，只有它们指向同一个对象时，==判断才会返回true，==不可用于比较类型上没有父子关系的两个对象
- equals()方法：Object默认提供的equals()只是比较对象的地址
重写equals()方法应满足下列条件：- 自反性：对任意x，x.equals(x)一定返回true
- 对称性：对任意x和y，如果y.equals(x)返回true，则x.equals(y)也返回true
- 传递性：对任意x,y,z，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)一定返回true
- 一致性：对任意x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应该保持一致，要么一直true，要么一直false
- 对任何不是null的x，x.equals(null)一定返回false
三、类成员
1、理解类成员
2、单例（Singleton）类
如果一个类始终只能创建一个实例，则这个类被称为单例类。
代码示例
class Singleton {
// 使用一个类变量来缓存曾经创建的实例
private static Singleton instance;
// 对构造器使用private修饰，隐藏该构造器
private Singleton() {
}
// 提供一个静态方法，用于返回Singleton实例
// 该方法可以加入自定义控制，保证只产生一个Singleton对象
public static Singleton getInstance() {
// 如果instance为null，则表明还不曾创建Singleton对象
// 如果instance不为null，则表明已经创建了Singleton对象
// 将不会重新创建新的实例
if (instance == null) {
// 创建一个Singleton对象，并将其缓存起来
instance = new Singleton();
}
return instance;
}
}
public class SingletonTest {
public static void main(String[] args) {
// 创建Singleton对象不能通过构造器
// 只能通过getInstance方法来得到实例
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);// 将输出true
}
}四、final修饰符
final关键字可用于修饰类、变量和方法
- 修饰变量时，表示该变量一旦获得了初始值就不可被改变
1、final成员变量
- final修饰的成员变量必须由程序员显示地指定初始值
- 类变量：必须在静态初始化块中指定初始值或声明该类变量时指定初始值，而且只能在两个地方的其中之一指定
- 实例变量：必须在非静态初始化块、声明该实例变量或构造器中指定初始值，而且只能在三个地方的其中之一指定
2、final局部变量
public class FinalLocalVariableTest {
public void test(final int a) {
// 不能对final修饰的形参赋值，下面语句非法
// a=5;
}
public static void main(String[] args) {
// 定义final局部变量时指定默认值，则str变量无法重新复制
final String str = "hello";
// 下面赋值语句非法
// str = "Java";
// 定义final局部变量时没有指定默认值，则d变量可被赋值一次
final double d;
// 第一次赋初始值，成功
d = 5.6;
// 对final变量重复赋值，下面语句非法
// d = 3.4;
}
}3、final修饰基本类型变量和引用类型变量的区别
- 当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。
- 对于引用类型变量而言，它保存的仅仅是一个引用，final只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变
代码示例
import java.util.Arrays;
class Person {
private int age;
public Person() {
}
// 有参数的构造器
public Person(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class FinalReferenceTest {
public static void main(String[] args) {
// final修饰数组变量，iArr是一个引用变量
final int[] iArr = { 5, 6, 12, 9 };
System.out.println(Arrays.toString(iArr));
// 对数组元素进行排序，合法
Arrays.sort(iArr);
System.out.println(Arrays.toString(iArr));
// 对数组元素赋值，合法
iArr[2] = -8;
System.out.println(Arrays.toString(iArr));
// 下面语句对iArr重新赋值，非法
// iArr = null;
// final修饰Person变量，p是一个引用变量
final Person p = new Person(45);
// 改变Person对象的age实例变量，合法
p.setAge(23);
System.out.println(p.getAge());
// 下面语句对p重新赋值，非法
// p = null;
}
}4、final方法
- final修饰的方法不可被重写
5、final类
- final修饰的类不可以有子类
6、不可变类
- 创建该类的实例后，该实例的实例变量是不可改变的
- 创建自定义的不可变类：
- 使用private和final修饰符来修饰该类的成员变量
- 提供带参数构造器，用于根据传入参数来初始化类的成员变量
- 仅为该类的成员变量提供getter方法，不要为该类的成员变量提供setter方法
- 如果有必要，重写Object类的hashCode()和equals()方法。equals()方法根据关键成员变量来作为两个对象是否相等的标砖，除此之外，还应该保证两个equals()方法判断为相等的对象的hashCode()也相等。
代码示例
public class Address {
private final String detail;
private final String postCode;
// 在构造器里初始化两个实例变量
public Address() {
this.detail = "";
this.postCode = "";
}
public Address(String detail, String postCode) {
this.detail = detail;
this.postCode = postCode;
}
// 仅为两个实例变量提供getter方法
public String getDetail() {
return detail;
}
public String getPostCode() {
return postCode;
}
// 重写equals()方法，判断两个对象是否相等
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj != null && obj.getClass() == Address.class) {
Address ad = (Address) obj;
// 当detail和postCode相等时，可认为两个Address对象相等
if (this.getDetail().equals(ad.getDetail())
&& this.getPostCode().equals(ad.getPostCode())) {
return true;
}
}
return false;
}
public int hashCode() {
return detail.hashCode() + postCode.hashCode() * 31;
}
}7、缓存实例的不可变类
- 如果程序经常需要使用相同的不可变类实例，则应该考虑缓存这种不可变类的实例
使用数组作为缓存池，实现一个缓存实例的不可变类
class ChacheImmutale {
private static int MAX_SIZE = 10;
// 使用数组来缓存已有的实例
private static ChacheImmutale[] cache = new ChacheImmutale[MAX_SIZE];
// 记录缓存实例在缓存中的位置，cache[pos-1]是最新缓存的实例
private static int pos = 0;
private final String name;
private ChacheImmutale(String name) {
this.name = name;
}
public String getName() {
return name;
}
public static ChacheImmutale valueOf(String name) {
// 遍历已缓存的对象
for (int i = 0; i < MAX_SIZE; i++) {
// 如果已有相同实例，则直接返回该缓存的实例
if (cache[i] != null && cache[i].getName().equals(name)) {
return cache[i];
}
}
// 如果缓存池已满
if (pos == MAX_SIZE) {
// 把缓存的第一个对象覆盖，即把刚刚生成的对象放在缓存池的最开始位置
cache[0] = new ChacheImmutale(name);
// 把pos设为1
pos = 1;
} else {
// 把新创建的对象缓存起来，pos加1
cache[pos++] = new ChacheImmutale(name);
}
return cache[pos - 1];
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj != null && obj.getClass() == ChacheImmutale.class) {
ChacheImmutale ci = (ChacheImmutale) obj;
return name.equals(ci.getName());
}
return false;
}
public int hashCode() {
return name.hashCode();
}
}
public class ChacheImmutaleTest {
public static void main(String[] args) {
ChacheImmutale c1 = ChacheImmutale.valueOf("hello");
ChacheImmutale c2 = ChacheImmutale.valueOf("hello");
// 下面代码将输出true
System.out.println(c1 == c2);
}
}Integer类构造器和valueOf()方法存在的差异
public class IntegerTest {
public static void main(String[] args) {
// 生成新的Integer对象
Integer in1 = new Integer(6);
// 生成新的Integer对象，并缓存该对象
Integer in2 = Integer.valueOf(6);
// 直接从缓存中取出Integer对象
Integer in3 = Integer.valueOf(6);
System.out.println(in1 == in2);// 输出false
System.out.println(in2 == in3);// 输出true
// 由于Integer只缓存-128~127之间的值
// 因此200对应的Integer对象没有被缓存
Integer in4 = Integer.valueOf(200);
Integer in5 = Integer.valueOf(200);
System.out.println(in4 == in5);// 输出false
}
}五、抽象类
1、抽象方法和抽象类
- 抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法
- 抽象方法和抽象类的规则：
- 抽象方法和抽象类必须使用abstract修饰符来定义，抽象方法不能有方法体
- 抽象类不能被实例化
- 抽象类可以包含成员变量、方法（普通方法和抽象方法）、构造器、初始化块、内部类（接口、枚举）5种成分
- 含有抽象方法的类只能被定义成抽象类
Shape抽象类
public abstract class Shape {
{
System.out.println("执行Shape的初始化块...");
}
private String color;
// 定义一个计算周长的抽象方法
public abstract double calPerimeter();
// 定义一个返回形状的抽象方法
public abstract String getType();
// 定义Shape的构造器，该构造器并不是用于创建Shape对象
// 而是用于被子类调用
public Shape() {
}
public Shape(String color) {
System.out.println("执行Shape的构造器...");
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}定义一个三角形类
public class Triangle extends Shape {
// 定义三角形的三边
private double a;
private double b;
private double c;
public Triangle(String color, double a, double b, double c) {
super(color);
setSides(a, b, c);
}
public void setSides(double a, double b, double c) {
if (a >= b + c || b >= a + c || c >= a + b) {
System.out.println("三角形两边之和必须大于第三边");
return;
}
this.a = a;
this.b = b;
this.c = c;
}
// 重写Shape类的计算周长的抽象方法
public double calPerimeter() {
return a + b + c;
}
// 重写Shape类的返回形状的抽象方法
public String getType() {
return "三角形";
}
}定义一个Circle普通类
public class Circle extends Shape {
private double radius;
public Circle(String color, double radius) {
super(color);
this.radius = radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
// 重写Shape类的计算周长的抽象方法
public double calPerimeter() {
return 2 * Math.PI * radius;
}
// 重写Shape类的返回形状的抽象方法
public String getType() {
return getColor() + "圆形";
}
public static void main(String[] args) {
Shape s1 = new Triangle("黑色", 3, 4, 5);
Shape s2 = new Circle("黄色", 3);
System.out.println(s1.getType());
System.out.println(s1.calPerimeter());
System.out.println(s2.getType());
System.out.println(s2.calPerimeter());
}
}注意：abstract不能用于修饰成员变量和局部变量，也不能用于修饰构造器。static和abstract不能同时修饰某个方法，即没有所谓的类抽象方法，但它们可以同时修饰内部类。abstract修饰的方法必须被其子类重写，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。
2、抽象类的作用
六、Java 9 改进的接口
1、接口的概念
- 接口定义的是多个共同的公共行为规范，这些行为是与外部交流的通道，这就意味着接口里通常是定义一组公用方法
2、Java 9 中接口的定义
[修饰符] interface 接口名 extends 父接口1，父接口2...
{
零个到多个常量定义...
零个到多个抽象方法定义...
零个到多个内部类、接口、枚举定义...
零个到多个私有方法、默认方法或类方法定义...
}接口里不能包含构造器和初始化块定义
接口里定义成员变量只能在定义时指定默认值，public static final修饰符可省略
public interface Output { // 接口里定义的成员变量只能是常量 int MAX_CACHE_LINE = 50; // 接口里定义的普通方法只能是public的抽象方法 void out(); void getData(String msg); // 在接口中定义默认方法，需要使用default修饰 default void print(String... msgs) { for (String msg : msgs) { System.out.println(msg); } } // 在接口中定义默认方法，需要使用default修饰 default void test() { System.out.println("默认的test()方法"); } // 在接口中定义类方法，需要使用static修饰 static String staticTest() { return "接口里的类方法"; } // 定义私有方法 private void foo() { System.out.println("foo 私有方法"); } // 定义私有静态方法 private static void bar() { System.out.println("bar 私有静态方法"); } }
3、接口的继承
interface InterfaceA {
int PROP_A = 5;
void testA();
}
interface InterfaceB {
int PROP_B = 6;
void testB();
}
interface InterfaceC extends InterfaceA, InterfaceB {
int PROP_C = 7;
void testC();
}
public class InterfaceExtendsTest {
public static void main(String[] args) {
System.out.println(InterfaceC.PROP_A);
System.out.println(InterfaceC.PROP_B);
System.out.println(InterfaceC.PROP_C);
}
}4、使用接口
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分
}代码示例
//定义一个Product接口
interface Product {
int getProduceTime();
}
//让Printer类实现Output和Product接口
public class Printer implements Output, Product {
private String[] printData = new String[MAX_CACHE_LINE];
// 用以记录当前需打印的作业数
private int dataNum = 0;
public void out() {
// 只要还有作业，就继续打印
while (dataNum > 0) {
System.out.println("打印机打印: " + printData[0]);
// 把作业队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData, 1, printData, 0, --dataNum);
}
}
public void getData(String msg) {
if (dataNum >= MAX_CACHE_LINE) {
System.out.println("输出队列已满，添加失败");
} else {
// 把打印数据添加到队列里，已保存数据的数量加1
printData[dataNum++] = msg;
}
}
public int getProduceTime() {
return 45;
}
public static void main(String[] args) {
// 创建一个Printer对象，当成Output使用
Output o = new Printer();
o.getData("轻量级Java EE企业应用实战");
o.getData("疯狂Java讲义");
o.out();
o.getData("疯狂Android讲义");
o.getData("疯狂Ajax讲义");
o.out();
// 调用Output接口中定义的默认方法
o.print("孙悟空", "猪八戒", "白骨精");
o.test();
// 闯将一个Printer对象，当成Product使用
Product p = new Printer();
System.out.println(p.getProduceTime());
// 所有接口类型的引用变量都可直接赋给Object类型的变量
Object obj = p;
}
}5、接口和抽象类
- 相同点
- 接口和抽象类都不能被实例化
- 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须事先这些抽象方法
- 不同点
- 接口里只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法
- 接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量
- 接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作
- 接口里不能包含初始化块；但抽象类则完全可以包含初始化块
- 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足
6、面向接口编程
- 简单工厂模式
- 命令模式
七、内部类
1、非静态内部类
- 外部类2个作用域：public和省略访问控制符
- 内部类4个作用域
- 非静态内部类里不能有静态方法、静态成员变量、静态初始化块
public class Cow {
private double weight;
// 外部类的两个重载的构造器
public Cow() {
}
public Cow(double weight) {
this.weight = weight;
}
// 定义一个非静态内部类
private class CowLeg {
// 非晶态内部类的两个实例变量
private double length;
private String color;
// 非静态内部类的两个重载的构造器
public CowLeg() {
}
public CowLeg(double length, String color) {
this.length = length;
this.color = color;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
// 非静态内部类的实例方法
public void info() {
System.out.println("当前牛腿颜色是: " + color + "，高: " + length);
// 直接访问外部类的private修饰的成员变量
System.out.println("本牛腿所在奶牛重: " + weight);
}
}
public void test() {
CowLeg c1 = new CowLeg(1.12, "黑白相间");
c1.info();
}
public static void main(String[] args) {
Cow cow = new Cow(378.9);
cow.test();
}
}- 外部类成员变量、内部类成员变量与内部类里方法的局部变量同名，则可以通过使用this、外部类类名.this作为限定区分
public class DiscernVariable {
private String prop = "外部类的实例变量";
public class InClass {
private String prop = "内部类的实例变量";
public void info() {
String prop = "局部变量";
// 通过外部类类名.this.varName访问外部类实例变量
System.out.println("外部类的实例变量值: " + DiscernVariable.this.prop);
// 通过this.varName访问内部类实例的变量
System.out.println("内部类的实例变量值: " + this.prop);
// 直接访问局部变量
System.out.println("局部变量的值: " + prop);
}
}
public void test() {
InClass in = new InClass();
in.info();
}
public static void main(String[] args) {
new DiscernVariable().test();
}
}- 非静态内部类的成员可以访问外部类的private成员，但反过来就不成立了
public class Outer {
private int outProp = 9;
class Inner {
private String inProp = "内部类的实例变量";
public void accessOuterProp() {
// 非静态内部类可以直接访问外部类的private成员变量
System.out.println("外部类的outProp值: " + outProp);
}
}
public void accessInnerProp() {
// 外部类不能直接访问非静态内部类的实例变量
// 下面代码出现编译错误
// System.out.println("内部类的inProp值: " + inProp);
// 如需访问内部类的实例变量，必须显示创建内部类对象
System.out.println("内部类的inProp值: " + new Inner().inProp);
}
public static void main(String[] args) {
// 执行下面代码，值创建了外部类对象，还未创建内部类对象
Outer out = new Outer();
out.accessInnerProp();
}
}2、静态内部类
- 静态内部类可以包含静态成员，也可以包含非静态成员
public class AccessStaticInnerClass {
static class StaticInnerClass {
private static int prop1 = 5;
private int prop2 = 9;
}
public void accessInnerProp() {
// System.out.println(prop1);
// 上面代码出现错误，应改为如下形式
// 通过类名访问静态内部类的类成员
System.out.println(StaticInnerClass.prop1);
// System.out.println(prop2);
// 上面代码出现错误，应改为如下形式
// 通过实例访问静态内部类的实例成员
System.out.println(new StaticInnerClass().prop2);
}
}- 接口内部类只能是静态内部类，访问控制符只能是public，默认使用public static
3、使用内部类
- 在外部内内部使用内部类
- 在外部类以外使用非静态内部类：OuterClass.InnerClass varName 、 OuterInstance.new InnerConstructor();
- 如果希望在外部类以外的地方访问内部类（包括静态和非静态两种），则内部类不能使用private访问控制权限
class Out{
//定义一个内部类，不使用访问控制符
//即只有同一个包中的其他类可访问该内部类
class In{
public In(String msg) {
System.out.println(msg);
}
}
}
public class CreateInnerInstance {
public static void main(String[] args) {
// Out.In in = new Out().new In("测试信息");
Out.In in;
Out out = new Out();
in = out.new In("测试信息");
}
}- 在外部类以外使用静态内部类：new OuterClass.InnerConstructor()
class StaticOut {
// 定义一个静态内部类，不使用访问控制符
// 即只有同一个包中的其他类可访问该内部类
static class StaticIn {
public StaticIn() {
System.out.println("静态内部类的构造器");
}
}
}
public class CreateStaticInnerInstance {
public static void main(String[] args) {
// StaticOut.StaticIn in = new StaticOut.StaticIn();
StaticOut.StaticIn in;
in = new StaticOut.StaticIn();
}
}4、局部内部类
- 不能使用访问控制符和static修饰符修饰
public class LocalInnerClass {
public static void main(String[] args) {
// 定义局部内部类
class InnerBase {
int a;
}
// 定义局部内部类的子类
class InnerSub extends InnerBase {
int b;
}
// 创建局部内部类的对象
InnerSub is = new InnerSub();
is.a = 5;
is.b = 8;
System.out.println("InnerSub对象的a和b实例变量是: " + is.a + "," + is.b);
}
}5、Java 8 改进的匿名内部类
- 匿名内部类适合创建那种只需要一次使用的类，不能重复使用
- 匿名内部类不能是抽象类
- 匿名内部类不能定义构造器
new 实现接口() | 父类构造器(实参列表)
{
//匿名内部类的类体部分
}八、Java 8 新增的Lambda表达式
1、Lambda表达式入门
三部分组成
- 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略
- 箭头(->)。必须通过英文中画线和大于符号组成。
- 代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么这条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回这条语句的值。
interface Eatable {
void taste();
}
interface Flyable {
void fly(String weather);
}
interface Addable {
int add(int a, int b);
}
public class LambdaQs {
// 调用该方法余姚Eatable对象
public void eat(Eatable e) {
System.out.println(e);
e.taste();
}
// 调用该方法需要Flyable对象
public void drive(Flyable f) {
System.out.println("我正在驾驶: " + f);
f.fly("【碧空如洗的晴日】");
}
// 调用该方法需要Addable对象
public void test(Addable add) {
System.out.println("5与3的和为: " + add.add(5, 3));
}
public static void main(String[] args) {
LambdaQs lq = new LambdaQs();
// Lambda表达式的代码块只有一条语句，可以省略花括号
lq.eat(() -> System.out.println("苹果的味道不错"));
// Lambda表达式的形参列表只有一个形参，可以省略圆括号
lq.drive(weather -> {
System.out.println("今天天气是: " + weather);
System.out.println("直升机飞行平稳");
});
// Lambda表达式的代码块只有一句话，可以省略花括号
// 代码块中只有一条语句，即使表达式需要返回值，也可以省略return关键字
lq.test((a, b) -> a + b);
}
}2、Lambda表达式与函数式接口
- Lambda表达式的类型，也被称为“目标类型”，Lambda表达式的目标类型必须是“函数式接口”。函数式接口代表只包含一个抽象方法的接口。函数式接口可以包含多个默认方法、类方法，但只能声明一个抽象方法。
九、枚举类
1、枚举类入门
- 枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是默认继承Object类，其中java.lang.Enum类实现了java.lang.Serializable和java.lang.Comparable两个接口
- 使用enum定义、非抽象的枚举类默认会使用final修饰，因此枚举类不能派生子类
- 枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认使用private修饰；如果强制指定访问控制符，则只能指定private修饰符
- 枚举类的所有实例必须在枚举类的第一行显示列出，否则这个枚举类永远都不能产生实例。列出这些实例时，系统会自动添加public static final修饰，无须程序员显示添加
枚举类默认提供了一个values()方法，该方法可以很方便地遍历所有的枚举值
public enum SeasonEnum {
//在第一行列出4个枚举实例
SPRING,SUMMER,FALL,WINTER;
}Test类
public class EnumTest {
public void judge(SeasonEnum s) {
// switch语句里的表达式可以是枚举值
switch (s) {
case SPRING:
System.out.println("春");
break;
case SUMMER:
System.out.println("夏");
break;
case FALL:
System.out.println("秋");
break;
case WINTER:
System.out.println("冬");
break;
}
}
public static void main(String[] args) {
// 枚举类默认有一个values()方法，返回该枚举类的所有实例
for (SeasonEnum s : SeasonEnum.values()) {
System.out.println(s);
}
// 使用枚举实例时，可通过EnumClass.variable形式来访问
new EnumTest().judge(SeasonEnum.SPRING);
}
}2、枚举类的成员变量、方法和构造器
public enum Gender {
//此处的枚举值必须调用对应的构造器来创建
MALE("男"),FEMALE("女");
private final String name;
//枚举类的构造器只能使用private修饰
private Gender(String name){
this.name = name;
}
public String getName() {
return this.name;
}
}Test类
public class GenderTest {
public static void main(String[] args) {
// 通过Enum的valueOf()方法来获取指定枚举类的枚举值
Gender g = Enum.valueOf(Gender.class, "FEMALE");
g.setName("女");
System.out.println(g + "代表: " + g.getName());
// 此时设置name值时将会提示参数错误
g.setName("男");
System.out.println(g + "代表: " + g.getName());
}
}十、对象在内存中的状态
- 可达状态：当一个对象被创建后，若有一个以上的引用变量引用它，则这个对象在程序中处于可达状态，程序可通过引用变量来调用该对象的实例变量和方法。
- 可恢复状态：系统的垃圾回收机制准备回收该对象所占用的内存，在回收该对象之前，系统会调用所有可恢复状态对象的finalize()方法进行资源清理。如果系统在调用finalize()方法时重新让一个引用变量引用该对象，则这个对象会再次变为可达状态；否则该对象将进入不可达状态。
- 不可达状态：当对象与所有引用变量的关联都被切断，且系统已经调用所有对象的finalize()方法后依然没有使该对象变成可达状态，那么这个对象将永久性地失去引用，最后变成不可达状态。只有当一个对象处于不可达状态是，系统才会真正回收该对象所占有的资源。
2、强制垃圾回收
- 调用System类的gc()静态方法：System.gc()。
- 调用Runtime对象的gc实例方法：Runtime.getRuntime.gc()。
投递字节跳动等公司7个岗位
阿里云工作强度 727人发布