JavaSE 进阶 (2) 多态

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public class Animal {
	public void eat() {
		System.out.printun("动物吃东西");
	}
}

public class Cat extends Animal {

	
	@Override
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

public class Dog extends Animal {

	
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

//动物操作类
public class AnimalOperator {
	public void useAnimal(Cat c) {
		c.eat();
	}
	
	public void useAnimal(Dog d) {
		d.eat();
	}
}

public class AnimalDemo {
	public static void main(string[] args) {
		//创建动物操作类的对象，调用方法
		AnimalOperator ao = new AnimalOperator();
		Cat c = new Cat();
		ao.useAnimal(c);  //猫吃鱼
		
		Dog d = new Dog();
		ao.useAnimal(d);  //狗吃骨头
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public class Animal {
	public void eat() {
		System.out.printun("动物吃东西");
	}
}

public class Cat extends Animal {

	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

public class Dog extends Animal {

	
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
	
	public void LookDoor() {
		System.oUt.println("狗看门");
	}

}

//动物操作类
public class AnimalOperator {
	public void useAnimal(Animal a) {  //Animal a = new Cat();   Animal a = new Dog();
		a.eat();
		//a.LookDoor();  //编译看左边, Animal中没有LookDoor()方法, 报错
	}
}

public class AnimalDemo {
	public static void main(string[] args) {
		//创建动物操作类的对象，调用方法
		AnimalOperator ao = new AnimalOperator();
		Cat c = new Cat();
		ao.useAnimal(c);  //猫吃鱼
		
		Dog d = new Dog();
		ao.useAnimal(d);  //狗吃骨头
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}
}

public class Cat extends Animal {

	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	
    public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

public class AnimalDemo {
	public static void main(string[] args) {
		//向上转型
		Animal a = new Cat();
		a.eat();
		//a.playGame();  报错
		
		//我现在想使用playGame()怎么办
		//①创建Cat对象
		Cat c = new Cat();
		c.eat();
		c.playGame();
		
		//②向下转型
		Cat c = (Cat)a;  //父类引用转为子类对象
		c.eat();
		c.playGame();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

public class  Animal {
	private String name;
	private int age;

	public Animal() {
	}

	public Animal(String name,int age) {
		this.name name;
		this.age age;
	}
	
	public void eat() {
		System.oUt.println("动物吃东西")；
	}
	
	
//set/get......
}

public class Cat extends Animal {
	public cat(){
	}

	public Cat(String name, int age) {
		super(name, age);
	}
	
    @Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

public class Dog extends Animal {
	public Dog(){
	}

	public Dog(String name, int age) {
		super(name, age);
	}

    @Override
	public void eat(){
		System.out.println("狗吃骨头");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		//按照多态的方式创建对象并进行测试
		Animal a = new Cat();
		a.setName("加菲");
		a.setAge(5);
		System.out.println(a.getName（）+ "," +a.getAge());
		a.eat();
	
		a = new Cat("加菲"，5);
		System.out.println(a.getName() + "," + a.getAge());
		a.eat();
	}
}

1
2
3

public abstract class Animal {
	public abstract void eat();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//抽象类
public abstract class Animal {
	//抽象方法
	public abstract void eat();

	public void sleep() {
		System.out.println("睡觉");
	}
}

public class Cat extends Animal {
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		Animal a = new Cat();  //抽象类多态
		a.eat();
		a.sleep();  //sleep()通过继承得到的
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

//抽象类
public abstract class Animal {
	private int age = 20;
	private final String name = "动物";
	
	public Animal() {
	}
	
	public Animal(int age) {
		this.age = age;
	}
	
	public void show() {
		age = 40;
		System.out.println(age);
		//name = "老虎"；报错 name是常量不能被修改
		System.out.println(name);
	}
	
	
	public abstract void eat();
}

public class Cat extends Animal {
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		Animal a = new Cat();  //抽象类多态
		a.eat();
		a.show();  //通过继承得到的  40  动物
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

public abstract class Animal {
	private String name;
	private int age;

	public Animal() {
	}

	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public abstract void eat();
	
	
	//set/get......
}

public class Cat extends Animal {
	public Cat() {
	}

	public Cat(String name, int age) {
		super(name, age);
	}
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		//按照多态的方式创建对象并进行测试
		Animal a = new Cat();
		a.setName("加菲");
		a.setAge(5);
		System.out.println(a.getName() + "," + a.getAge());
		a.eat();
	
		a = new Cat("加菲"，5);
		System.out.println(a.getName() + "," + a.getAge());
		a.eat();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public interface Inter {
	public abstract void show();
}

public class InterImpl implments Inter {

	@Override
	public void show() {
		System.out.println("show...");
	}
}

public class InterDemo {
	public static void main(String[] args) {
		Inter i = new InterImpl();  //接口的多态
		i.show();
	}
}

1
2

public abstract class InterImpl implments Inter {
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public interface Inter {
	public int num = 10;
	public final int num2 = 20;
	
	public abstract void show();
}

public class InterDemo {
	public static void main(String[] args) {
		Inter i = new InterImpl();
		System.out.println(i.num);  //10
		System.out.println(i.num2);  //20
		//i.num = 40;  报错,默认前边加了一个final,被final修饰,不能修改
		//i.num2 = 30;  报错,被final修饰,不能修改
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//public class InterImpl implements Inter{
public class InterImpl extends Object implements Inter {
	public InterImpl() {
		super();
	}
	
	@Override
	public abstract void show() {
		System.out.println("show...");
	}
}

1
2
3
4
5
6
7

// 类和接口的关系
public class InterImpl extends Object implements Inter1,Inter2,Inter3{
}

// 接口和接口的关系
public interface Inter3 extends Inter1,Inter2{
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

 /*
	报警接口
*/
public interface Alarm {
	void alarm();
}

/*
	抽象门类
*/
public abstract class Door {
	//宽
	private double width;
	//高
	private double height;
	//品牌
	private String brand;
	//开门
	public abstract void open();
	//关门
	public abstract void close();
	
	public Door() {
	}
	
	public Door(double width,double height,String brand) {
		this.width = width;
		this.height = height;
		this.brand = brand;
	}
	
	//set/get......
}

/*
	木门
*/
public class WoodDoor extends Door {
	
	@Override
	public void open() {
		System.out.println("手动开门")；
	}

	@Override
	public void close() {
		System.out.println("手动关门")；
	}
	
	
	public WoodDoor() {
	}

	public WoodDoor(double width,double height,String brand) {
		super(width,height,brand);
	}
}

/*
	电动报警门
*/
public class ElectricAlarmDoor extends Door implents Alarm {

	public ElectricAlarmDoor() {
	}

	public ElectricAlarmDoor(double width,double height,String brand) {
		super(width,height,brand);
	}

	@Override
	public void alarm() {
		System.out.println("具有报警功能")；
	}

	@Override
	public void open() {
		System.oUt.println("自动开门")；
	}

	@Override
	public void close() {
		System.oUt.println("自动关门")；
	}
}

/*
	测试类
*/
public class DoorDemo {
	public static void main(String[] args) {
		//木门
		WoodDoor wd = new WoodDoor();
		wd.open();
		wd.close();
		//wd.alarm();   报错,没有这个功能
		
		//电动报警门
		ElectricAlarmDoor ed = new ElectricAlarmDoor();
		ed.open();
		ed.close();
		ed.alarm();
		
		//多态
		Door d = new WoodDoor();
		d.open();
		d.close();

		d = new ElectricAlarmDoor();
		d.open();
		d.close();
		//d.alarm();  报错,因为门这个抽象类里没有报警的方法
		
		Alarm a = new ElectricAlarmDoor();
		//a.open();  报错,因为报警的接口中没有开门和关门的方法
		//a.close();  报错,因为报警的接口中没有开门和关门的方法

		a.alarm();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public interface Inter {
	public default void show1() {
		System.out.println("默认方法被调用")；
	}
}

public class InterImpl implements Inter {

}

public class InterDemo {
	public static void main(String[] args) {
		Inter i = new InterImpl();
		i.show1();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public interface Inter {
	public static void show2() {
		System.out.println("静态方法被调用")；
	}
}

public class InterImpl implements Inter {

}

public class InterDemo {
	public static void main(String[] args) {
		Inter i = new InterImpl();
		//i.show2();  报错,不能通过对象.方法名调用
		//InterImpl.show2();   报错,不能通过实现类.方法名调用
		Inter.show2();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public interface Inter {
	//默认方法
	public default void show1() {
		System.out.println("默认方法被调用");
		show3();
		show4();
	}
	
	//静态方法
	public static void show2() {
		System.out.println("静态方法被调用")；
		//show3(); 报错,静态的方法只能访问静态的方法
		show4();
	}
	
	//私有方法
	private void show3() {
		System.out.println("私有方法")；
	}
	
	//静态私有方法
	private static void show4() {
		System.out.println("静态私有方法")；
	}
}

public class InterImpl implements Inter {

}

public class InterDemo {
	public static void main(String[] args) {
		Inter i = new InterImpl();
		//i.show3();  报错,因为私有方法在外界是不能访问的
		//i.show4();  报错,因为私有方法在外界是不能访问的
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

/*
函数式接口
1.interface接口，其次有且只能有一个待实现的抽象方法，允许有default默认方法的存在
2.@FunctionalInterface 编译期检测是否符合函数式接口的规范，类似于@Override
3.建议加上注解@FunctionalInterface, 以避免同事接口改造升级，而带来的简化出现问题
*/

@FunctionalInterface
interface MyFunctionalInterfacel {
	void test();
	//void a();
	
	default void b(){};
}
-----------------------------------------
class Test {
	public void method(MyFunctionalInterfacel my) {
		my.test();
	}
}
-----------------------------------------
public class FunctionalDemo1 {
	public static void main(String[] args) {
		Test test = new Test();
		test.method(() -> System.out.println("Hello!"));  //匿名内部类，重写MyFunctionalInterfacel中的抽象方法
	}
}

1
2
3
4
5

//问候
@FunctionalInterface
public interface GreetingService {
	void sayMessage();
}

1
2
3
4
5
6
7

public class GreetingServiceImpl implements GreetingService {
	
	@Override
	public void sayMessage() {
		System.out.println("say hello!");
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class Demo {
	//定义一个方法，参数使用函数式接口GreetingService
	public static void show(GreetingService greetingService) {
		greetingService.sayMessage();
	}
	
	public static void main(String[] args) {
		//调用show方法，方法的参数是一个接口，所以可以传递接口的实现类
		show(new GreetingServiceImpl());
		
		//调用show方法，方法的参数是一个接口，所以可以传递接口的匿名内都类
		show(new GreetingService(){
			@Override
			public void sayMessage(){
				System.out.println("使用匿名内类重写接口中的抽象方法");
			}
		});
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

/*
通过lambda + Functional Interface的好处？
1.简化代码，使代码更加简洁
2.延迟加载效果
需求：日志记录(时间+异常类型+异常信息行数) 日志级别达到3才需要记录输出
*/

@FunctionalInterface
interface MyFunctionalInterface2{
	//记录日志的操作
	void test();
}
----------------------------------------
public class FunctionalDemo2{

	/**
	* 日志记录器
	* @param leveL  日志级别
	* @param msg    日志信息
	*/
	public static void testLog(int level, string msg){
		if(level == 3){
			System.out.println(msg);
		}
	}
	
	/**
	* 带有函数式接口FunctionalInterface的，日志记录器
	* @param leveL  日志级别
	* @param my
	*/
	public static void testLogAndFunctionalInterface(int level, MyFunctionalInterface2 my){
		if(level == 3){
			my.test();
		}
	}
	
	public static void main(string[] args){
		//日志记录(时间+异常类型+异常信息行数)
		LocalDateTime now = LocalDateTime.now();
		String type = "NullPointerException";
		String line = "Bank.java 112";

		//无论是否符合日志等级，都将会先拼接好日志信息
		testLog(1, now + "," + type + "," + line);

		//等级一旦不符合，不会进行日志信息的拼接操作
		testLogAndFunctionalInterface(2, () -> System.out.println(now + "," + type + "," + line));
	}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class Test {
	public static void main(string[] args) {
		String msgA = "hello";
		String msgB = "world";
		String msgC = "java";
		showLog(1, msgA + msgB + msgc);
	}
	
	private static void showLog(int level,String msg) {
		//当日志级别为1时，打印日志
		if(level == 1) {
			System.out.println(msg);
		}
	}

}

1
2
3
4

@FunctionalInterface
interface MessageBuilder {
	String buildMessage();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Test {
	public static void main(string[] args) {
		String msgA = "hello";
		String msgB = "world";
		String msgC = "java";
		
		//lambda实现显示日志
		showLogLambda(1,() -> msgA + msgB + msgC);
		
		//证明lambda表达式的延迟执行
		showLogLambda(1, () -> {
			System.out.printIn("Lambda执行！");
			return msgA + msgB + msgC;
		});
	}
	
	private static void showLogLambda(int level, MessageBuilder builder) {
		if(level == 1){
			System.out.println(builder.buildMessage());
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class TestSupplier {
	private static String getString(Supplier<String> function) {
		return function.get();
	}

	public static void main(String[] args) {
		String msgA = "Hello";
		String msgB = "World";
		System.out.println(getstring(() -> msgA + msgB));
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
* supplier<T> 函数式接口 @FunctionalInterface
* 1.供给型
* 2.java.util.function  JDK1.8
* 3.T get()；提供一个与泛型一致的数据
*/
public class SupplierDemo {
	public static String testGet(Supplier<string> supplier) {
		string s = supplier.get();
		return s;
	}
	
	public static void main(String[] args) {
		String str1 = testGet(new Supplier<string>() {
			@Override
			public String get(){
				String string = "abc";
				return string.toUppercase();
			}
		});
		System.out.println("str1 =" + str1);//ABC
		
		System.out.println("-----Lambda简化----");
		
		String str2 = testGet(() -> "AAA".toLowercase());//aaa
		System.out.println(str2);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class MaxValue {

    public static int getMax(Supplier<Integer> s) {
        return s.get();
    }
    private MaxValue() {
    }
}

public class TestOne {
    public static void main(String[] args) {
        int[] arr = {7, 4, 9, 2, 6};
        int max = MaxValue.getMax(() -> {
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
        System.out.println("最大值:" + max);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
* Consumer<T>
* 1.消费型  函数式接口  @FunctionalInterface
* 2.java.util.function  JDK1.8
* 3.void accept(T t);  需要传递一个与泛型类型一致的数据，没有返回值
* Consumer<T> andThen(Consumer<? super T> after)
* 4.需要传递一个与泛型类理一致的数据
*/
public class ConsumerDemo {

	public static void testAccept(Consumer<Integer> consumer, Integer i) {
		consumer.accept(i);
	}
	
	public static void main(String[] args) {
		system.out.println("-----------void accept(T t)----------");
		testAccept(new Consumer<Integer>(){
			@override
			public void accept(Integer integer){
				integer += 100;
				System.out.println("integer = " + integer);//110
			}
		}, 10);
		
		System.out.println("-----void accept(T t)简化------")；
		testAccept(i -> {
			i *= 10;
			System.out.println("i =" + i); //1000
		}, 100);
	}
}