黑马程序员_Java学习日记第三天-多态、内部类、异常处理

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

多态：

1.多态的实现

父类的引用也可以接收自己的子类对象

2.多态的前提

必须是类与类之间有关系，要么继承，要么实现

通常还有一个前提，就是存在覆盖

3. 多态的好处

大大的提高了程序的扩展性

4.多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类的成员

5.多态的应用

在多态中成员函数的（非静态）特点：

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

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

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）。

在多态中静态成员函数的特点：无论编译和运行，都参考左边。

多态自始至终都是子类对象在做着变化

举例：

abstract class CZStudent

{

public abstract void study();

public void sleep()

{

System.out.println("bedsleep");

}

}

class DoStudent

{

public void doStudent(CZStudent stu)

{

stu.study();

stu.sleep();

}

}

class BaseStudentextends CZStudent

{

public void study()

{

System.out.println("BaseStudy");

}

public void sleep()

{

System.out.println("Standsleep");

}

}

class AdvStudentextends CZStudent

{

public void study()

{

System.out.println("AdvStudy");

}

}

public class Polymorphism

{

public static void main(String[] args)

{

DoStudent ds=new DoStudent();

ds.doStudent(new BaseStudent());

ds.doStudent(new AdvStudent());

}

}

运行结果：BaseStudy

Standsleep

AdvStudy

bedsleep

举例：电脑运行实例

interface PCI

{

publicvoid open();

publicvoid close();

}

class MainBoard

{

public void run()

{

System.out.println("MainBoardRun");

}

public void usePCI(PCI p)

{

if(p!=null)

{

p.open();

p.close();

}

}

}

class NetCardimplements PCI

{

public void open()

{

System.out.println("NetCardOpen");

}

public void close()

{

System.out.println("NetCardClose");

}

}

class SoundCardimplements PCI

{

public void open()

{

System.out.println("SoundCardOpen");

}

public void close()

{

System.out.println("SoundCardClose");

}

}

public classPerson_Computer

{

public static void main(String[] args)

{

MainBoard mb=new MainBoard();

mb.run();

mb.usePCI(new NetCard());

mb.usePCI(new SoundCard());

}

}

内部类的访问规则：

1.内部类可以直接访问外部类中的成员，包括私有成员。

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

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

访问格式：

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

格式

外部类名.内部类名变量名 = 外部类对象.内部类对象

当内部类在成员位置上，就可以被成员修饰符所修饰

比如,private:将内部类在外部类中进行封装。

static:内部类就具备static的特性

注意：当内部类中定义了静态成员，该内部类必须是static的

当外部类的静态方法访问内部类时，内部类也必须是static的

内部类只能访问被final修饰的局部变量

匿名内部类举例：

interface Inter

{

void method();

}

class Test

{

static Inter function()

{

return new Inter()

{

public void method()

{

System.out.println("method run");

}

};

}

}

public class InnerClassTest

{

public static void main(String[] args)

{

Test.function().method();

}

}

 

 

异常处理：

 

try:捕获异常

catch：处理异常

finally：无论有无异常，都要执行的代码

throw：抛出一个异常

throws:声明可能抛出一个异常

 

举例：

class Demo

{

int div(int a,int b)throws Exception

{

return a/b;

}

}

public class Exceptions

{

public static void main(String[] args)

{

Demo d=new Demo();

try

{

int x=d.div(7,2);

System.out.println("x="+x);

}

catch(Exception e)

{

System.out.println("By Zero");

System.out.println(e.getMessage());

System.out.println(e.toString());

e.printStackTrace();

}

}

}

多异常处理：

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

2. 对方声明几个异常，就对应有几个catch块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承RuntimeException。

对于异常，分两种：

1.编译时被检测的异常；

2.编译时不被检测的异常（运行时异常，RuntimeException以及其子类）

{1) Checked exception:这类异常都是Exception的子类。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。

2) Unchecked exception:这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是非法的，它们不能通过client code来试图解决，所以称为Unchecked exception。}

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。

要么在内部try catch处理。

要么在函数上声明让调用者处理。

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

发现打印的结果中只有异常的名称，却没有异常的信息，因为自定义的异常并未定义信息。

因为父类中已经把异常信息的操作完成了。

所以子类只要在构造时，将异常信息通过super语句传递给父类。

那么就可以直接通过getmessage方法获取自定义的异常信息。

举例：（自定义异常）

class FuShuExceptionextends Exception

{

private int value;

FuShuException(String msg,int value)

{

super(msg);

this.value=value;

}

public int getValue()

{

return value;

}

}

class Div

{

publicint div(int a,int b)throws FuShuException

{

if(b<0)

throw new FuShuException("除数中出现负数了...",b);

return a/b;

}

}

public class SelfException

{

public static void main(String[] args)

{

Div d=new Div();

try

{

int x=d.div(1,-2);

System.out.println("x="+x);

}

catch(FuShuExceptione)

{

System.out.println(e.toString());

System.out.println("错误的负数是"+e.getValue());

}

}

}

 

自定义异常：

 

必须是继承自Exception类

原因：异常体系有一个特点，因为异常类和异常对象都被抛出。

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

Exception中有一个特殊的子类异常RuntimeException运行时异常。

如果在函数内抛出异常，函数上可以不用声明，编译一样通过。

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

常用的RuntimeException有：NullPointerException空指针异常、ArrayIndexOutofBoundsException数组角标越界异常、StringIndexOutOfBoundsException字符串角标越界异常、ClassCastException类转换异常、ConcurrentModificationException并发修改异常等

 

error和exception有什么区别?

error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。exception表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

 

总结：

包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰符。

不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限只有两种：public , protected

                 public   protected   default   private

同一个类中   OK           OK                  OK           OK

同一个包中  OK           OK                   OK           NO

子类                OK            OK                 NO            NO

不同包中       OK           NO                 NO            NO

举例：

package packb;

publicclass DemoB

{

protectedvoid show()

{

System.out.println("DemoBshow run");

}

}

--------------------------

package packa;

public class DemoAextends packb.DemoB

{

public void show()

{

super.show();

System.out.println("DemoA show run");

}

}

--------------------------

package pack;

public class Demo

{

public static void main(String[] args)

{

packa.DemoA d = new packa.DemoA();

d.show();

}

}

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