final/抽象类/interface

2018-06-18 01:17:20来源：未知阅读 ()

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

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有