黑马程序员 Java基础接口、内部类及异常

 ------- android培训、java培训、期待与您交流！ ----------

 

interface接口：

特点：1，接口中常见定义：常量，抽象方法。2，接口中的成员变量有固定的修饰符。常量：public static final。方法public abstract。

注意，接口中的成员都是public的。

接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆写后子类才可以实例化，否则子类是一个抽象类。

接口可以被类多实现，因为由于父类中的方法有重复所以不可以继承，而接口是没有方法体“{}“的。

接口的特点：

1.接口是对外暴露的规则。

2.接口是程序的功能扩展。

3.接口可以用来多实现。

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5.接口与接口自减可以有继承关系。

interface Inter{public static final int NUM=3;public abstract void show();}class Test implements Inter{public void show(){}}class InterfaceDemo {public static void main(String[] args) {Test t=new Test();System.out.println(t.NUM);System.out.println(Test.NUM);System.out.println(Inter.NUM);}}

 

多态：可以理解为事物存在的多种体现形态。

1.多态的体现：父类的引用指向了自己的子类对象。（类型提升--向上转型）这里要说明的是，也可以强制将父类的引用转成子类类型--向下转型。

2.多态的好处：多态的出现提高了程序的扩展性。

3.多态的前提：必须是类与类之间有关系，要么继承要么实现，通常还有一个前提：覆盖。

4.多态的弊端：只能使用父类的引用访问父类中的成员。

多态中成员函数的特点：

1.在编译时期参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过如果没有，编译失败。

2.在运行时参阅对象所属的类中是否有调用的方法。

多态中成员变量的特点：

无论编译和运行都参考左边（引用型变量所属的类）。

多态中静态成员函数的特点

无论编译和运行都参考左边。

interface Usb{public void start();public void stop();}class MoveDisk implements Usb{public void start(){System.out.println("MoveDisk start...");}public void stop(){System.out.println("MoveDisk stop...");}}class Mp3 implements Usb {public void start(){System.out.println("Mp3 start...");}public void stop(){System.out.println("Mp3 stop...");}}class Computer{public void work(Usb u){u.start();u.stop();}}class TestInterface{public static void main(String[]args){new Computer().work(new MoveDisk());new Computer().work(new Mp3());}}

 

内部类的访问规则：

1.内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员是因为内部类中持有了一个外部类的引用。格式：外部类名.this。

2.外部类要访问内部类必须建立内部类对象。’

访问格式：

1.当内部类定义在外部类的成员位置上，而且非私有可以在外部其他类中直接建立内部类对象。

格式：外部类.内部类 变量名=外部类对象.内部类对象，Outer.Inner in=new Outer().Inner()。

2.当内部类在成员位置上，就可以被成员修饰符所修饰。比如：private，将内部类在外部类中进行封装。static，内部类就是具备静态特性。

当内部类被static修饰后只能直接访问外部类中的static成员，出现访问局限。

在外部其他类中如何直接访问非静态内部类：new Outher.Inner().function()

如何访问静态：Outher.Inner.function()

 

public class Test8 {public static void main(String[] args) {new Outer().method();   //建立外部类对象并调用method方法。}}class Outer{String str="hello Outer";void method(){class Inter{    //创建内部类String str="hi inter";void funiction(){System.out.println("Outer="+Outer.this.str);  //打印外部类的字符串变量信息System.out.println("Inter="+this.str);  //打印外部类的字符串信息}}new Inter().funiction();   //建立内部类的对象并调用funiction方法。}}

内部类定义在局部时：

1.不可以被成员修饰符修饰

2可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

class Outer{int x=3;void method(){final int y=4;class Inner{void function(){System.out.println(y);}}new Inner().function();}}class InnerClassDemo{public static void main(String[] args){new Outer().method();}}

匿名内部类：

1.匿名内部类就是内部类的简写。

2.定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3.格式：

new 父类或接口（）

{

定义子类内容；

}

4.其实匿名内部类就是一个匿名子类对象。

class Outer{int x=3;public void function(){new AbsDemo(){void show(){System.out.println("x="+x);}}}}

异常的处理：

异常的处理可以由，try、catch与finally三个关键字所组成的程序快组成。

一般格式：
try{
要检查的语句
}
catch(异常类 名称){
处理语句
}
finally{       //finally快可省略
一定会运行语句
}
1，try程序快若有异常发生，程序的运行中断，并抛出异常类的对象。
2，抛出的异常如果的是catch所捕获的异常则捕获异常，然后进入到catch快中继续运行。
3，无论try程序快是否捕捉到异常，或者捕捉到的异常是否与catch（）括号中的异常相同
都一定执行finally中的程序代码。   
另一种方式是交由Java虚拟机的异常处理机制做处理，但这种方式通常只能输出异常信息，
接着便停止运行。 
throws，如果方法内的程序代码可能会发生异常，而且方法内又没有try-catch异常，则需
声明方法时一并指出可能发生的异常，以便让调用此方法的程序准备捕捉。
throw，用来抛出一个异常类的实例对象。
try，检查程序快中的语句是否有异常。
catch，捕捉异常，并做出相应的处理。
finally，一定会执行到的代码语句，常用来关闭资源。
try块中是可以抛出异常的，需要catch或者继续抛出。

class TestException{public static void main(String[] args){int a=4,b=0;try{if(b==0)throw new ArithmeticException("一个算数异常。");elseSystem.out.println(a+"/"+b+"="+a/b);}catch(ArithmeticException e){System.out.println("抛出异常为："+e);}}}

 

对多异常的处理：

1.声明异常时建议声明更为具体的异常，这样处理更具体。

2.对方声明几个异常就对应几个catch快。如果多个catch快中的异常出现继承关系父类异常catch快放在最下面。

一般情况下，函数内出现异常，函数上需要声明。

如何定义异常：

因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时将异常信息传给父类，通过supper语句就可以通过getMessage方法获取自定义的异常信息。

RuntimeException运行时异常：

如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常，调用者可以不用进行处理编译一样通过。

异常在子父类覆盖中的体现：

1.子类在覆写父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类异常或者该异常的子类。

2.如果父类方法抛出多个异常，那么子类在覆盖该方法时只能抛出父类异常的子集。

3.如果父类或者接口方法中没有异常抛出，那么子类在覆盖方法时也不能抛异常，如果出现了异常，只能try...catch。