Java基础10-接口,抽象类以及异常

原创 2012年04月05日 22:20:20

一.接口
 1.什么是接口
  接口是特殊的抽象类,其内部方法都是抽象的
 
 2.接口与抽象类的区别:
  a.接口是interface;抽象类是abstract class
  b.接口的方法都是抽象的;抽象类的方法可以不是抽象的
  c.接口的成员有默认修饰符:方法是public abstract,变量是public static final;抽象类没有默认修饰符
  d.接口的实现使用implements关键字;抽象类的继承使用extends关键字
  e.接口可以被多实现;抽象类只能被单继承
  
 
3.什么时候使用抽象类和接口?
  a.当存在继承关系时使用抽象类;没有继承关系时就使用接口
  b.当方法都是抽象时使用接口;若既有抽象方法,又有实例方法时,使用抽象类
  
 
注:
  接口与接口,使用extends关键字;
  实现接口后,子类方法必须为public;
  
 
4.面试题一:
  一个类可以实现两个接口吗?任意两个接口都可以吗?
  
  答: 可以.不可以.
   因为若是两个接口的方法名相同,参数列表相同,但其返回值类型不同,此时子类就不能同时实现这两个接口了.
   如:
    interface A {
     int fun();
    }
    interface B {
     void fun();
    }
 
 5.面试题二:
  什么情况下,会将子类类型强转为父类类型呢?
  
  答:当一个子类对象能够匹配多个重载方法而且方法的形参都是该子类实现的父类类型们.
  这时会出现调用不明确的情况,所以需要进行强转为父类类型.
  如:
   interface Teacher {
    void teach();
   }
   interface Coder {
    void code();
   }
   
   class Person implements Teacher,Coder {
    public static void main(String[] args) {
     Person p = new Person();
     p.work( (Teacher)p );  //强转类型转换
     p.work( (Coder)p );    //强转类型转换
    }
    
    @Override
    public void teach(){ }
    
    @Override
    public void code(){ }
    
    public static void work(Teacher t) {
     t.teach();
    }
    
    public static void work(Coder c) {
     c.code();
    }
   }
   
二.策略设计模式-StrategyPattern
 使用接口,降低耦合性
 
 如:
  class TestDemo {
   public static void main(String[] args) {
    int[] arr={1,4,6,7,3,5,9,-6,-34,67,-12};
    Printer.print(arr);
    
    //需求: 要打印其中的正数 (此时就可以使用策略设计,添加过滤器,使用接口来实现)
    
    Printer.print(arr, new Filter(){  //add: 使用匿名内部类
     @Override
     public boolean accept() {
      return i >= 0;
     }  
    });
    
   } 
  }
  
  class Printer {
   public static void print(int[] arr) {
    for(int i=0;i<arr.length;i++)
     System.out.print(arr[i]+" ");
    System.out.println();
   }
   
   public static void print(int[] arr,Filter f) {       //add
    for(int i=0;i<arr.length;i++)
     if(f.accept(arr[i]))                         //add
      System.out.print(arr[i]+" ");
    System.out.println();
   }
  }
  
  interface Filter {
   boolean accept(int i);
  }
  
  
三.内部类: ( 内部类可以访问外部类成员 )
 
类中:
  成员内部类
  静态内部类
 
方法中: 
  局部内部类
  匿名内部类
 
 
1.什么是内部类
  在内部类中定义的类,就是内部类
  
 2.成员内部类: ( A$B.class )
 
 a.什么是成员内部类
   定义在类的成员位置的内部类,就是成员内部类
   创建该内部类的对象,必须先创建外部类对象,才能通过外部类对象创建内部类对象;
  注:
   创建格式为: 外部类名.内部类名 变量名= new 外部类名().new 内部类名();
   一个外部类可以创建多个内部类对象,但一个内部类对象只能对应一个外部类对象;
   
  b.什么时候使用成员内部类?
   当一个类想要访问另一个类的成员时
  
  
c.内部类访问外部类的成员的方式:
   使用: 外部类名.this.成员名 


  注:
   在方法中,"this" 代表当前方法的对象,而"外部类.this" 代表当前方法的对象的外部类对象
   外部类不能访问内部类成员
   
  
d.内部类中不能定义静态成员
   因为内部类必须依赖外部类对象才能创建对象,而static是指不需创建对象就可以使用
   
 
3.局部内部类: ( A$1B.class )
 
 a.什么是局部内部类
   定义在方法中的内部类,就是局部内部类
   
  b.局部内部类与成员内部类的区别:
   局部内部类,只能在方法中使用;成员内部类可以在外面使用
   创建局部内部类的代码在方法中,而且必须写在类定义的后面;
      
  
c.方法中的内部类怎么创建对象
   在方法中直接使用 new 类名()即可
   
  d.方法中的内部类怎么访问方法中的局部变量
   局部内部类访问方法的局部变量时,该局部变量必须使用final修饰;  
   
  如:
   class TestDemo {
    public static void main(String[] args) {
     new A().fun();
    } 
   }
   
   class A {
   
    class B {
     B() {
      System.out.println("成员内部类B..");
     }
    }
    
    void fun() {
    
     class B {
      B() {
       System.out.println("局部内部类B..");
      }
     }
     
     /*
     B b = new B(); 
//1.这边创建B对象是根据从内到外的优先级进行选择的,只有当内部不存在就会向外寻找
     */
     
     //需求: 当前代码下,
     //创建成员内部类B的对象:
A.B b2 = new A.B();
     //创建外类B的对象的方法:
包名.B b3 = new 包名.B();
     
    }
   }
   
   class B {
    B() {
     System.out.println("外部类B..");
    }
   }
   
   
 
4.匿名内部类 ( A$1.class )
 格式:
  new 父类名(){
   //重写方法
  }


  a.什么是匿名内部类
   没有名字的局部内部类,就是匿名内部类
  
  b.什么时候使用匿名内部类
   局部内部类只需使用一次,使用匿名内部类可以简化书写
 
  c.匿名内部类的class文件名
   A$1.class
   
 5.静态内部类
  a.什么是静态内部类
   使用static修饰的内部类
   
  b.静态内部类和普通的类中内部类的区别
   创建对象: 静态内部类不需创建外部类对象,就可以直接建立内部内部类 ( 外部类名.内部类名 变量名 = new 外部类名.内部类名(); )
       成员内部类需要通过创建外部类对象来创建自己的对象 ( 外部类名.内部类名 变量名 = new 外部类名().new 内部类名(); )
   访问外部成员: 静态内部类只能访问外部类的静态成员,而不能访问非静态成员
   定义静态成员: 静态内部类可以定义静态成员;而成员内部类是不可以定义静态成员( 静态变量/方法/代码块 ),可以定义静态常量
   


三.异常
 
 Throwable
 --Error
    --
 --Exception
    --RuntimeException
    --
  
 1.什么是异常
  异常就是程序运行过程中出现的一些错误, 使用throw关键字抛出的一些对象.
  可以通知调用处, 调用处下面的代码不会再执行了.
  
 2.异常的处理方式
 
 a.声明
   若是没有处理,则需要在方法上(参数列表后面)使用"throws 异常名"进行声明,将异常继续向上抛出
  
  b.捕捉
   try {
   
   }catch(异常名 变量名) {
    //处理代码
   }
  
 3.异常的分类
 
 a.编译时异常
   Exception中除了RuntimeException的部分, 编译之前在代码中必须对其进行声明或捕捉, 否则编译报错
   
  b.运行时异常
   RuntimeException或其子类, 在代码中可以不对其进行处理, 编译不报错.
   这类异常经常会出现, 例如数组索引越界, 空指针, 算数异常, 如果对其进行处理, 非常麻烦, 代码可读性也会下降.
   
 4.多个异常的处理方式
  a.声明
   在方法上使用"throws 异常1名,异常2名"进行声明
  
 
 b.捕捉
   try {
   
   }catch(异常1名 变量名) {
    //处理代码
   }catch(异常2名 变量名) {
    //处理代码
   }


  注:
   异常捕捉的书写顺序: 子类异常放在前面
  
 5.子类重写父类方法时注意的异常问题
  重写的条件之一: 子类的方法只能抛出父类方法异常的子集,不能抛出比父类更多的异常
 如:
  class A {
   void fun() throws Exception {
   
   }
  }
  
  class B {
   @Override
   public void fun() throws FileNotFoundException { //可以不抛,也可以抛出相同的异常,也可以抛出父类异常的子类!!!!
   
   }
  }
  
 6.finally的使用
  finally是配合try使用的, 只要执行了try中的代码, finally中的代码就一定会执行. (一些特殊情况除外:如System.exit(0); )
 
 注:
  class TestDemo {
   public static void main(String[] args) throws Exception {   
    /*
    打印结果一:(System.out,println(10/1);)
     10
     异常处理之前
     finally语句
     
    打印结果二:(System.out,println(10/0);)
     异常处理
     finally语句
    */
    try {
     System.out.println(10/1);           //
     System.out.println("异常处理之前");
     return ;
    }catch(Exception e) {
     System.out.println("异常处理..");
    
    }finally {    
     System.out.println("finally语句");
    }
   } 
  }
  
  
补充:
 猴子分桃问题
 注:
  class TestDemo {
   public static void main(String[] args) {   
    
    outer:
     for(int i=0;i<9999;i++) {
      int count=i; 
      for(int j=0;j<5;j++){
       if( (count-1)%5==0 )
        count = (count-1)/5*4;
       else
        continue outer;
      }  
      System.out.println(i);       
     }
    
   } 
   
  }

Java 抽象类,抽象方法和接口

讲述Java中抽象类,抽象方法和接口的各种用法。
  • ccpat
  • ccpat
  • 2015年03月26日 20:50
  • 2394

java中抽象方法和抽象类实现模版模式

实现模板模式有以下三个步骤: 1、在抽象类中,把固定的内容,存放到一个方法中(如final修饰的方法), 在该方法中,不确定部分,调用该抽象类中的抽象方法。 2、子类重写该抽象类的抽象方法。 ...
  • smile_from_2015
  • smile_from_2015
  • 2015年12月07日 16:44
  • 1836

java 第五章作业:抽象类

题目: 首先编写一个抽象类,要求该抽象类有3个抽象方法:     public abstract void f(int x);     public abstract void g(int x,i...
  • oPrinceLi
  • oPrinceLi
  • 2013年04月11日 21:47
  • 1482

从模板方法模式深入理解Java抽象类

阿里面试的时候被问到:接口不能实现,必须由抽象类实现的典型场景?这不就是典型的模板方法模式嘛!钩子方法和具体方法的存在使抽象类与接口具有了最主要的差异: 接口主要体现的是一种规范,实现接口的类只能去实...
  • zhangliangzi
  • zhangliangzi
  • 2016年05月22日 17:12
  • 1668

Java抽象类及子类实例化顺序和方法调用顺序测试

测试目的 验证抽象类及子类实例化顺序; 验证抽象类是否可以在子类未实例化时调用子类实现的抽象方法; 验证java的多态性 实例抽象类:package com.secbro.test.abstractI...
  • wo541075754
  • wo541075754
  • 2016年05月28日 10:15
  • 3258

java抽象类。抽象类里面的抽象方法必须被子类全部复写

抽象类:包含抽象方法的类称为抽象类。 抽象方法:只声明而未实现的方法称为抽象方法。必须使用abstract关键字声明。 *抽象类和抽象方法都必须使用abstract关键字声明。 *抽...
  • jks456
  • jks456
  • 2014年10月31日 13:22
  • 3059

抽象类、抽象方法、接口的区别及实现

一、抽象类、抽象方法 抽象方法:类的成员方法,只有声明,没有实现,把实现交给子类。 抽象类:含有抽象方法的类。 1.有抽象方法的类一定是抽象类,但抽象类里可以没有抽象方法(当然也...
  • aionbo
  • aionbo
  • 2016年10月17日 11:49
  • 873

请问java中,抽象类里的抽象方法都要在它的子类中全部实现吗?能不能有些抽象方法不实现?

请问java中,抽象类里的抽象方法都要在它的子类中全部实现吗?能不能有些抽象方法不实现?  分享| 2015-05-27 21:22忆晨儿 | 浏览 1161 次  来自:手机知道 ...
  • evilcry2012
  • evilcry2012
  • 2016年04月13日 09:37
  • 4403

JAVA的修饰词(3)----abstract 抽象类

1.引入概念:狼和狗,两个类,抽取他们所属的共性:犬科。 犬科都有吼叫行为,具体是汪汪汪还是嗷嗷嗷,是不确定的,需要子类明确。 这些犬科不具体的功能,需要在类中标识出来,通过java中的关键字ab...
  • yusenDong
  • yusenDong
  • 2017年02月12日 15:35
  • 371

java中抽象类与接口中方法访问修饰符问题

转自:http://blog.sina.com.cn/s/blog_7ffb8dd5010111yu.html             http://www.blogjava.net/hwpok/a...
  • lwwgtm
  • lwwgtm
  • 2013年03月19日 21:33
  • 11134
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础10-接口,抽象类以及异常
举报原因:
原因补充:

(最多只允许输入30个字)