final/抽象類/interface
阿新 • • 發佈：2018-05-10
onu 汽車 休息 st3 generated 不能 running 最終 one
lesson Thirteen 2018-05-10 02:10:43
final:
最終的，可以修飾類、屬性、方法
1.final修飾類：這個類就不能被繼承，如：String類，StringBuffer類，System類
1 class SubString extends String{
2 //The type SubString cannot subclass the final class String
3 }
4 final class A{
5
6 }
7 class B extends A{
8 //The type B cannot subclass the final class A
9 }
2.final修飾方法：不能被重寫 如：object的getclass();方法(獲取當前對象的類名)
1 class C{
2 public final void f() {
3 System.err.println("被final修飾的方法1");
4 }
5 }
6 class D extends C{
7 public void f() {
8 System.err.println("被final修飾的方法2");
9 //Cannot override the final method from C
10 }
11 }
3.final修飾屬性：此屬性就是一個常量，習慣常量用全大寫表示
3.1此常量不能默認初始化
3.2可以顯式賦值、代碼塊、構造器
1 class E{
2 final int INT = 123;
3
4 public void e() {
5 System.err.println(INT);
6 INT= 12;
7 //The final field E.INT cannot be assigned
8 }
9 }
abstract:
抽象的，可以修飾類、方法 即，抽象類，抽象方法 不能修飾屬性、構造器、private、final、static
1.1抽象類
1.1.1不可以被實例化
1.1.2抽象類有構造器（凡是類都有構造器）
1.1.3抽象方法所在的類，一定是抽象類
1.1.4抽象類中可以沒有抽象方法
1 abstract class eemployeee{
2 private String name;
3 private int id;
4 private double salary;
5 public String getName() {
6 return this.name;
7 }
8 public void setName(String name) {
9 this.name = name;
10 }
11 public int getId() {
12 return this.id;
13 }
14 public void setId(int id) {
15 this.id = id;
16 }
17 public double getSalary() {
18 return this.salary;
19 }
20 public void setSalary(double salary) {
21 this.salary = salary;
22 }
23
24 public abstract void work();
25 //這就是抽象方法，也可以沒有
26 }
1.2抽象方法
1.2.1格式：沒有方法體，包括{}。 如：public abstract void work();
1.2.2抽象方法只保留方法的功能，而具體的執行，交給繼承抽象類的子類，由子類重寫此抽象方法
1.2.3若子類繼承抽象類，並重寫了所以的抽象方法，則可以實例化，反之則不能
1 class Manager extends eemployeee{
2 private double bonus;
3 public double getBonus() {
4 return this.bonus;
5 }
6 public void setBonus(double bonus) {
7 this.bonus = bonus;
8 }
9 public void work(){
10 System.out.println("監督工作");
11
12 }
13 }
14
15 class CommonEmployee extends eemployeee{
16 public void work(){
17 System.out.println("工人在流水線工作");
18
19 }
20 }
interface:
接口,與類並行的概念
interface（接口）是與類並行的概念
1.接口可是看作是一個特殊的抽象類，是常量與抽象方法的集合。不能包含變量和一般的方法
2.接口是沒有構造器的
3.接口定義的就是一種功能，可以被類實現（implements）
如：class DD extends CC implements A
1 interface A {
2 //常量：所有的常量都用 public static final
3 int j =1;
4 public static final int i =0;
5 //抽象方法：所有的都用 public abstract修飾
6 void method1();
7 public abstract void method2();
8 }
4.實現接口的類，必須重寫其中所有的抽象方法，方可實例化，不然，此類仍為抽象類
1 interface A {
2 //常量：所有的常量都用 public static final
3 int j =1;
4 public static final int i =0;
5 //抽象方法：所有的都用 public abstract修飾
6 void method1();
7 public abstract void method2();
8 }
9
10
11
12 abstract class BB implements A {
13
14 }
5.類可以實現多個接口-----JAVA中的類是單繼承的
1 class CC extends DD implements A,B {
2 public void method1(){
3
4 }
5 public void method2(){
6
7 }
8 public void method3(){
9
10 }
11 }
6.接口與接口之間是繼承關系，而且可以多繼承
1 interface A {
2 //常量：所有的常量都用 public static final
3 int j =1;
4 public static final int i =0;
5 //抽象方法：所有的都用 public abstract修飾
6 void method1();
7 public abstract void method2();
8 }
9 interface B{
10 public abstract void method3();
11 }
12 interface C extends B,A{
13 public abstract void method4();
14 }
1 interface Runner{
2 public void Strat();
3 abstract void Run();
4 public abstract void Stop();
5
6 }
7
8 class Person implements Runner{
9
10 @Override
11 public void Strat() {
12 System.out.println("人在走路");
13 }
14
15 @Override
16 public void Run() {
17 System.out.println("人在跑");
18 }
19
20 @Override
21 public void Stop() {
22 System.out.println("人在休息");
23 }
24
25 public void Dance() {
26 System.out.println("人在跳舞");
27 }
28
29 }
30 class Car implements Runner{
31
32 @Override
33 public void Strat() {
34 System.out.println("汽車啟動");
35 }
36
37 @Override
38 public void Run() {
39 System.out.println("汽車在行駛");
40 }
41
42 @Override
43 public void Stop() {
44 System.out.println("汽車停了");
45 }
46
47 public void fillFuel(){
48 System.out.println("汽車在加油");
49 }
50 public void crack() {
51 System.out.println("撞車了");
52 }
53
54 }
55 class Bird implements Runner{
56
57 @Override
58 public void Strat() {
59 System.out.println("鳥在起飛");
60 }
61
62 @Override
63 public void Run() {
64 System.out.println("鳥在跑");
65 }
66
67 @Override
68 public void Stop() {
69 System.out.println("鳥停下了");
70 }
71
72 public void fly() {
73 System.out.println(" 鳥在飛 ");
74 }
75
76 }
interface的練習
1 public static void main(String[] args) {
2
3 interfaceTest1 i = new interfaceTest1();
4 Fly duck = new Duck();
5 i.test3(duck);
6
7 new interfaceTest1().test1(new Duck());
8 new interfaceTest1().test2(new Duck());
9 new interfaceTest1().test3(new Duck());
10 new interfaceTest1().test4(new Duck(), new Duck(), new Duck());
11 }
12
13 public void test1(Run duck){
14 duck.run();
15 // duck.fly();
16 // duck.swim();
17 }
18 public void test2(Swim duck){
19 // duck.fly();
20 duck.swim();
21 // duck.run();
22 }
23 public void test3(Fly duck){
24 // duck.run();
25 // duck.swim();
26 duck.fly();
27 }
28 public void test4(Run r, Swim s, Fly f){
29 r.run();
30 s.swim();
31 f.fly();
32 }
33
34
35
36
37
38
39
40 interface Run{
41 void run();
42 }
43 interface Swim{
44 void swim();
45 }
46 interface Fly{
47 void fly();
48 }
49
50 class Duck implements Run,Swim,Fly{
51
52 @Override
53 public void fly() {
54 System.out.println("flying");
55 }
56
57 @Override
58 public void swim() {
59 System.out.println("swimming");
60 }
61
62 @Override
63 public void run() {
64 System.out.println("running");
65 }
66
67 }
interface多態的運用1
1 public static void main(String[] args) {
2 Computer computer = new Computer();
3 computer.work(new Flash());
4 Printer p = new Printer();
5 computer.work(p);
6
7
8 USB phone = new USB(){
9
10 @Override
11 public void start() {
12 // TODO Auto-generated method stub
13 System.out.println("start working");
14 }
15
16 @Override
17 public void stop() {
18 System.out.println("stop working");
19 }
20
21 };
22
23
24 }
25
26
27
28
29
30
31 interface USB{
32 public static final int i = 10;
33 public abstract void start();
34 public abstract void stop();
35 }
36
37 class Flash implements USB {
38
39 @Override
40 public void start() {
41 System.out.println("閃存開始工作");
42 }
43
44 @Override
45 public void stop() {
46 System.out.println("閃存停止工作");
47 }
48
49 }
50
51 class Printer implements USB{
52
53 @Override
54 public void start() {
55 System.out.println("打印機開始工作");
56 }
57
58 @Override
59 public void stop() {
60 System.out.println("打印機停止工作");
61 }
62
63 }
interface多態的運用2
final/抽象類/interface