文章目录
- 简介
- 易错练习题
- 练习题1 代码改错
- 练习题2
- Lambda
- Lambda表达式 如果方法只有一个参数 可以不写数据类型和( )
- Lambda表达式 可以不写数据类型,会自动寻找
- Lambda表达式 没有返回值的方法
- 成员匿名内部类用Lambda省略
- 函数类接口
- ::操作符绑定静态 成员 构造 三种方法
- 静态
- 成员
- 构造
- 枚举
- switch语句使用枚举
- 枚举类的常用方法
- values()
- valueOf和compareTo()
- ordinal()
- 枚举的构造方法 枚举实现接口 枚举中声明抽象方法
- 枚举中重写父类方法,例如toString方法
简介
- 本文是2021/04/05整理的笔记
- 赘述可能有点多,还请各位朋友耐心阅读
- 本人的内容和答案不一定是最好最正确的,欢迎各位朋友评论区指正改进
易错练习题
练习题1 代码改错
interface IA{
void m1();
int a = 100;
}
class MyClass implements IA{
void m1(){}
}
public class TestInterface{
public static void main(String args[]){
IA ia = new MyClass();
ia.m1();
System.out.println(IA.a);
}
}
答案:
将Myclass中的void m1()改为public void m1 ()
解析:
子类中的方法权限要大于等于父类的方法权限,返回值类型小于等于父类的返回值类型。
接口中方法默认为public static
实现类方法访问权限大于等于接口的,所以要public。
练习题2
interface IA{
void ma();
}
interface IB extends IA{
void mb();
}
interface IC{
void mc();
}
interface ID extends IB, IC{
void md();
}
- 如果有一个类 ClassE 实现 ID 接口,如果不希望 ClassE 是抽象的,则需要
实现哪些方法?
答案:
需要重写所有的方法,即ma() mb() mc() md()
解析:
实现类实现接口,实现类如果不是抽象类,必须覆盖重写接口的所有抽象方法。 - 把下面的代码补充完整
public class TestClassE{
public static void main(String args[]){
IC ic = new ClassE();
//调用 ma 方法
______________
//调用 mb 方法
______________
//调用 mc 方法
______________
//调用 md 方法
______________
}
}
答案:
//向下转型还原为ID类对象,即可调用所有方法
ID id = (ID) ic;
id.ma()
id.mb()
ic.mc()
id.md()
解析:
IC ic = new ClassE();
声明父类IC类引用,指向子类ClassE类对象。
IC类对象无法调用IA IB 和ID的方法。
需要向下转型还原为ID类或ClassE类,即可调用ma mb md方法
- 写出下面代码的输出结果
public class TestClassE{
public static void main(String args[]){
IC ic = new ClassE();
System.out.println(ic instanceof IA);
System.out.println(ic instanceof IB);
System.out.println(ic instanceof IC);
System.out.println(ic instanceof ID);
System.out.println(ic instanceof ClassE);
}
}
答案
true
true
true
true
true
解析:
instanceof 关键字 看的是运行期类型,本题中为ClassE,ClassE是IA IB IC ID 的子类对象,是ClassE类的本类对象。
Lambda
Lambda表达式 如果方法只有一个参数 可以不写数据类型和( )
public class Test1 {
public static void main(String[] args) {
/* 原式
A a = new A() {
@Override
public int m1(int x) {
return 2 * x;
}
};*/
/* 第一次化简
A a = (int x) -> 2*x; */
A a = x -> 2*x; //第二次化简
int i = a.m1(5);
System.out.println("i=" +i);
}
}
interface A{
int m1(int x);
}
Lambda表达式 可以不写数据类型,会自动寻找
public class Test1 {
public static void main(String[] args) {
/* 匿名内部类写法
A a = new A() {
@Override
public int m1(int x, int y) {
return x - y;
}
};*/
//Lambda表达式写法
A a = (x,y) -> x+y;
int i = a.m1(200, 100);
System.out.println("i = " + i);
}
}
interface A{
int m1(int x,int y);
}
Lambda表达式 没有返回值的方法
public class Test1 {
public static void main(String[] args) {
/*A a = new A() {
@Override
public void m1(String s) {
System.out.println("s = " + s);
}
};*/
A a = s -> System.out.println("s = " + s);
a.m1("Hello World");
}
}
interface A{
void m1(String s);
}
成员匿名内部类用Lambda省略
public class Test1 {
private String name = "张三";
private int age = 20;
/* 成员匿名内部类写法
B b= new B() {
@Override
public void show() {
System.out.println("name = " + name);
System.out.println("age = " + age);
}
};*/
//Lambda写法
B b = () -> System.out.println("name = " + name + " age = "+age);
public static void main(String[] args) {
Test1 test1 = new Test1();
test1.b.show();
}
}
@FunctionalInterface
interface B{
void show();
default void method() {
}
}
函数类接口
只有一个抽象方法的接口叫做函数类接口
@FunctionalInterface 检查是否是函数式接口
Lambda无法访问默认方法
Lambda表达式无法改变值
public class Test {
private final int age = 0;
public static void main(String[] args) {
int age = 20;
/*A a = new A() {
@Override
public void test() {
System.out.println("age = " + age);
m1();
}
};*/
A a = () -> System.out.println("age = " + age);
// m1();
;
a.test();
}
}
@FunctionalInterface
interface A{
void test();
default void m1(){
System.out.println("A.m1([])方法");
}
}
::操作符绑定静态 成员 构造 三种方法
静态
public class Test1 {
public static void main(String[] args) {
//接口A绑定Integer里的静态方法valueOf
A a = Integer::valueOf;
Integer method = a.method("1234567");
System.out.println("method = " + method);
}
}
interface A{
Integer method(String s);
}
成员
public class Test1 {
public void show(){
System.out.println("Hello World");
}
public static void main(String[] args) {
//绑定Test1的成员方法show
Test1 test1 = new Test1();
A a = test1::show;
a.method1();
}
}
interface A{
void method1();
}
构造
public class Person {
private String firstName;
private String lastName;
//无参构造
public Person() {
}
//有参构造
public Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
@Override
public String toString() {
return "Person{" +
"firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
'}';
}
public static void main(String[] args) {
//接口绑定构造方法
A a = Person::new;
Person abc = a.abc("彼得", "帕克");
System.out.println(abc);
}
}
interface A{
Person abc(String firstName, String lastName);
}
枚举
switch语句使用枚举
public class Test1 {
Signal color = Signal.RED;
public void change(){
switch (color){
//如果是红灯,变绿灯
case RED:color = Signal.GREEN;break;
//如果是绿灯,变黄灯
case GREEN: color = Signal.YELLO;break;
//如果是黄灯,变红灯
case YELLO: color = Signal.RED;break;
default: break;
}
}
public static void main(String[] args) {
//创建测试类对象
Test1 test1 = new Test1();
test1.change();
System.out.println("test1.color = " + test1.color);
}
}
enum Signal{
//绿灯 黄灯 红灯
GREEN,YELLO,RED
}
枚举类的常用方法
values()
public class Test1 {
public static void main(String[] args) {
//调用values方法,返回值类型为数组,创建一个枚举类型的数组接收
Signal[] values = Signal.values();
//增强for循环遍历输出
for (Signal value : values) {
System.out.println("枚举变量:" + value);
}
}
}
enum Signal{
//红灯 绿灯 黄灯
RED,GREEN,YELLO
}
valueOf和compareTo()
public class Test1 {
public static void main(String[] args) {
Sex sex = Sex.valueOf("MALE");
System.out.println("sex = " + sex);
Sex[] values = Sex.values();
for (Sex value : values) {
//比较
System.out.println("compare = "+ sex.compareTo(value));
}
}
}
enum Sex{
//男生 女生
MALE,FEMALE
}
ordinal()
枚举的构造方法 枚举实现接口 枚举中声明抽象方法
public class Test1 {
public static void main(String[] args) {
Color color = Color.GREEN;
Color color2 = Color.BLACK;
System.out.println("color2.getColor = " + color2.getColor());
System.out.println("color.getColor = " + color.getColor());
color.m1();
}
}
//声明枚举
enum Color implements A{
//红绿蓝黑
RED{
@Override
void m1() {
System.out.println("RED.m1([])方法");
}
@Override
public String getColor() {
return "红色";
}
},GREEN{
@Override
void m1() {
System.out.println("GREEN.m1([])方法");
}
@Override
public String getColor() {
return "绿色";
}
},BLUE{
@Override
void m1() {
System.out.println("BLUE.m1([])方法");
}
@Override
public String getColor() {
return "蓝色";
}
},BLACK{
@Override
void m1() {
System.out.println("BLACK.m1([])方法");
}
@Override
public String getColor() {
return "黑色";
}
};
private String name;
Color() {
System.out.println("Color.Color([])方法");
}
Color(String name) {
this.name = name;
System.out.println("Color.Color([name])方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
abstract void m1();
}
interface A{
String getColor();
}
枚举中重写父类方法,例如toString方法
public class Test1 {
public enum Color{
//红色,黄色,绿色
RED("红色",1),YELLOW("黄色",2),GREEN("绿色",3);
private String name;
private int index;
//无参构造方法
Color() {
}
//有参构造方法
Color(String name, int index) {
this.name = name;
this.index = index;
}
//重写toString方法
@Override
public String toString() {
return this.index+":"+this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED);
}
}