Java面向对象（八）

Java面向对象（八）


目录

• Java面向对象（八）
  
  
  
  • 
    
    
    
    • 二十四、abstract 关键字
      
      
      
      • 创建抽象类的匿名子类对象
        
      • 
        
      
      
    • 二十五、模板方法设计模式（TemplateMethod）
      
    • 二十六、接口（interface）
      
      
      
      • 26.1 接口简介：
        
      • 26.2 接口的定义和实现：
        
      • 26.3 接口的使用：
        
      • 26.4 接口的实现类的对象创建（例子）
        
      • 26.5 接口应用：代理模式（Proxy）
        
      • 26.6 特殊例子：
        
      • 26.7 Java8 接口新特性
        
      • 26.8 接口与抽象类的区别
        
      
      
    
    
  
  

二十四、abstract 关键字

• abstract 可以用来修饰的结构：类、方法。
  
• abstract 修饰类：抽象类。
  
  
  
  • 此类不能实例化。
    
  • 抽象类中一定有构造器，便于子类实例化时调用。（涉及：子类对象实例化的全过程）
    
  • 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。
    
  
  
• abstract 修饰方法：抽象方法。
  
  
  
  • 抽象方法只有方法的声明，没有方法体。
    
  • 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
    
  • 若子类重写了父类中的所有的抽象方法后，此子类方可实例化。若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰。
    
  
  
• 注意：
  
  
  
  • abstract 不能用来修饰：属性、构造器等结构。
    
  • abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。
    
  
  

创建抽象类的匿名子类对象

1. public class PersonTest {       
2.         public static void main(String[] args) {       
3.        
4.                 //非匿名的类非匿名的对象
5.                 Worker worker = new Worker();
6.                 method1(worker);
7.                 //非匿名的类匿名的对象
8.                 method1(new Worker());
9.                 //创建了一匿名子类的非匿名对象：p
10.                 Person p = new Person(){
11.                         @Override
12.                         public void eat() {
13.                                 System.out.println("吃东西");
14.                         }
15.                         @Override
16.                         public void breath() {
17.                                 System.out.println("好好呼吸");
18.                         }                       
19.                 };               
20.                 method1(p);
21.                 //创建匿名子类的匿名对象
22.                 method1(new Person(){
23.                         @Override
24.                         public void eat() {
25.                                 System.out.println("吃好吃东西");
26.                         }
27.                         @Override
28.                         public void breath() {
29.                                 System.out.println("好好呼吸新鲜空气");
30.                         }
31.                 });
32.         }               
33.         public static void method1(Person p){
34.                 p.eat();
35.                 p.breath();
36.         }       
37. }
38. class Worker extends Person{
39.         @Override
40.         public void eat() {
41.         }
42.         @Override
43.         public void breath() {
44.         }       
45. }

复制代码

二十五、模板方法设计模式（TemplateMethod）

• 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
  
• 解决的问题：
  当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
  换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。
  
• 例子：
  

1. public class TemplateTest {
2.         public static void main(String[] args) {
3.                
4.                 SubTemplate t = new SubTemplate();
5.                
6.                 t.spendTime();
7.         }
8. }
10. abstract class Template{
11.        
12.         //计算某段代码执行所需要花费的时间
13.         public void spendTime(){
14.                
15.                 long start = System.currentTimeMillis();
16.                
17.                 this.code();//不确定的部分、易变的部分
18.                
19.                 long end = System.currentTimeMillis();
20.                
21.                 System.out.println("花费的时间为：" + (end - start));
22.                
23.         }
24.        
25.         public abstract void code();
26. }
28. class SubTemplate extends Template{
30.         @Override
31.         public void code() {
32.                
33.                 for(int i = 2;i <= 1000;i++){
34.                         boolean isFlag = true;
35.                         for(int j = 2;j <= Math.sqrt(i);j++){
36.                                 if(i % j == 0){
37.                                         isFlag = false;
38.                                         break;
39.                                 }
40.                         }
41.                         if(isFlag){
42.                                 System.out.println(i);
43.                         }
44.         }
45.         }       
46. }

复制代码

26.8 接口与抽象类的区别

NO.区别点抽象类接口1定义包含抽象方法的类主要是抽象方法和全局常量的集合2组成构造方法、抽象方法、普通方法、 常量、变量常量、抽象方法、(jdk8.0:默认方法、静态方法)3使用子类继承抽象类(extends)子类实现接口(implements)4关系抽象类可以实现多个接口接口不能继承抽象类，但允许继承多个接口5常见设计模式模板方法简单工厂、工厂方法、代理模式6对象都通过对象的多态性产生实例化对象7局限抽象类有单继承的局限接口没有此局限8实际作为一个模板是作为一个标准或是表示一种能力9选择如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局

• 在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类， 要么实现接口。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！