黑马训练营-学习笔记----面向对象

------- android培训、java培训、期待与您交流！
----------
 
面向对象

把功能定义为对象的属性。。。。毕老师买电脑、软件公司、。。一切皆对象，万物皆对象；名词提炼法

 

面向对象：封装；继承；多态；

以后的开发其实就是找对象用，没有对象就创建一个对象

找对象，建立对象，维护对象

 

类和对象的关系

类就是对现实生活中事物的描述；对象就是这类事物，实实在在存在的个体；

映射到java中，描述就是class定义的类。

具体对象就是对应java在堆内存中用new建立的实体

 

成员变量，在函数里的是局部变量，成员变量作用于整个类中，局部变量作用于函数中或者语句中，成员变量在堆内存中，因为对象的存在，才在内存中存在，而局部变量存在于栈内存中

 

封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：将变化隔离；便于使用；提高重用性；提高安全性；

原则：将不需要对外提供的内容都隐藏起来；

      把属性都隐藏，提供公共方法对其访问

 

private:私有，权限修饰符，用于修饰类中成员（成员变量，成员函数），私有只在本类中有效

将成员私有后，类外即使建立对象也不能直接访问，需要在该类中提供对应的访问方式

注意:私有仅仅是封装的一种表现形式

之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句，对访问的数据进行操作，提高代码的健壮性

 

构造函数    
主要用于给对象初始化，对象一建立就会调用与之对应的构造函数；当一个类中没有定义构造函数，系统会默认给该类加入一个空参数的构造函数；当在类中有了自己定义的构造函数时，则没有了默认的构造函数

1.函数名与类名相同；2.不用定义返回值类型的；3.不可以写return；

构造函数是在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行，是给对象添加对象具备的功能；一个对象建立，构造函数只运行一次，而一般函数可以被该对象多次调用

多个构造函数是以重载的形式存在的

构造代码块--作用：给对象初始化；对象一建立就运行，而且优先于构造函数执行。     
构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，构造代码块定义的是不同对象的的共性初始化内容。

 

this关键字  
是为了区分局部变量和成员变量重名的情况

        this代表本类的对象，this代表它所在函数所述对象的引用，简单说，哪个对象在调用this所在的函数，this就代表哪个对象；当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用了本类对象，都用this

this可以用于构造函数之间互相调用，而且只能用this

this语句只能定义在构造函数的第一行，因为初始化要先执行

Person(String name)

{

         this.name=name;

}

 

Person(String name,int age)

{

         //this.name = name;

         this(name);//这里的this是在调用上面的构造函数

         this.age = age;

}

 

static关键字

static 是一个修饰符，用于修饰成员（成员变量，成员函数）,修饰的变量

就不存在与堆内存当中了，每个对象就都能访问到，而不是在每个对象中再单独创建

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可

以直接被类名调用   --类名.静态成员

静态变量会被存在内存的方法区（共享区/数据区）

static的特点

1.随着类的加载而加载

  也就是说：静态会随着类的消失而消失，它的生命周期最长

2.优先于对象存在

  静态是先存在的，对象是后存在的

3.被所有对象所共享

4.可以直接被类名所调用

 

实例变量和类变量的区别

1.存放位置。类变量随着类的加载而存在于方法区中，实例变量随着对象的建立而

           
存在于堆内存中

2.生命周期。类变量生命周期最长，随着类的消失而消失，实例变量生命周期随着对象的消失而消失

 

静态使用注意事项

1.静态方法只能访问静态成员，非静态方法可以既可以访问静态 
也可以访问非静态

2.静态方法中不可以定义this，super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3.主函数是静态的

 

静态有利有弊：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象都存在一份，可以直接被类名调用

弊端：生命周期过长，访问出现局限性（静态虽好，只能访问静态）

 

关于主函数

主函数是一个特殊的函数，作为程序的入口，可以被jvm调用

public static void main(String[] args)

public:代表着该函数有最大的访问权限。

static：代表着主函数随着类的加载就已经存在了

void：主函数没有具体的返回值

main：不是关键字，但是一个特殊的单词，可以被jvm识别

（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串，即字符串类型的数组

主函数是固定格式的，jvm识别

jvm在调用主函数时，传入的是new String[0]

 

静态的一个重要应用是工具类

每一个应用程序都有共性的功能，可以将这些功能抽取，独立封装，一边复用。这时就可以建立一个专门放功能方法的类，不需要独立运行，可以将其放在一个独立的java文件里，当所调用的函数编译时，会将该java文件先进行编译，生成class文件，从而实现其功能。

虽然可以通过建立工具类的对象使用这些工具方法，但是我们会发现，在工具类里并没有特有的数据，而对象是用来封装数据的，其次操作数组的每一个方法都没有用到工具类里对象中的特有数据，这时为了使程序更加严谨，我们可以将工具类里的方法都定义成static的，直接通过类名调用即可，而不用再创建对象。

将方法都静态后，可以便于使用，但是该类还是可以被其他程序建立对象，为了更加严谨，强制让该类不能创建对象，可以把构造函数也私有化

封装完以后就可以将编译生成的class文件给别人使用了，其他人只要将该文件设置到classpath路径下，就可以使用该类工具了，但是其他人并不知道该类定义了多少方法，对如何使用也不清楚，因为没有说明书。所以要制作说明书

java的说明书通过javadoc文档注释来完成

可以通过/**   */来分别对工具类中的各个方法进行说明，而且可以对该工具类的版本、作者等信息进行标识；然后在dos页面下通过调用javadoc指令自动生成该工具类的帮助文档，以网页的形式

 

静态代码块

格式：

static

{

        
静态代码块中的执行语句；

}

特点：随着类的加载而执行，只执行一次，用于给类进行初始化的，并优先于主函数执行。但凡用到了类中的内容，就会将类加载，就要执行静态代码块

 

一个非匿名对象的创建过程

1.因为new用到了class文件，所以会先找到该class文件并加载到内存中

2.如果该类中有static代码块，则执行该类中的static代码块，，给该class类进行初始化

3.在堆内存中开辟空间，分配内存地址

4.在堆内存中建立对象的特有属性，并进行默认初始化

5.对属性进行显示初始化

6.对对象进行构造代码块初始化

7.对对象进行对应的构造函数初始化

8.将内存地址给栈内存中的变量

 

一个类中默认会有一个空参数的构造函数

这个默认的构造函数的权限和所属的类一致

如果类被public修饰，那么默认的构造函数也带public修饰符

如果类没有被public修饰那么默认的构造函数也没有public修饰

即默认构造函数的权限是随着类的变化而变化的

 

设计模式：解决某一类问题最行之有效的方法

java中有23中设计模式

单例设计模式：解决一个类在内存中只存在一个对象

        

想要保证对象唯一

1.禁止其他程序建立该类的对象

2.但为了让其他程序能够访问到该累的对象，只好在本类中自定义一个对象

3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方法

 

对于编写代码来说就是

1.将构造函数私有化

2.在类中定义静态的私有的本类对象

3.提供一个方法可以获取该对象

 

对于事物该怎么描述还怎么描述

当需要将该事物的对象保证在内存中唯一时，就将以上三步加上即可

 

class Single

{

         private int num;

         public void setNum(int num)

         {

                  this.num = num;

         }

         public int getNum()

         {

                  return num;

         }

         private Single(){}     //将构造函数私有化

         private static Single s = new Single();   //创建类中的对象，需是静态的私有的

         public  static Single getInstance()                 //获取该对象的方法，类型是Single的静态的

         {

                  return s;

         }

}

 

class SingleDemo

{

         public static void main(String[] args)

         {

                  Single ss = Single.getInstance();

                  Single sss = Single.getInstance();

                  ss.setNum(23);

                  System.out.println(sss.getNum());//这时ss和sss指向的是同一个对象，即Single类中的对象s

         }

}

 

//单模式的另一种写法是：

/*

class Single

{

         private static Single s =null;

         private Single(){}

         public static Single getInstance()

         {

                  if(s==null)

                          s=new Single();

                  return s;

         }

}

 

上面那种方法是先初始化对象，称为饿汉式，而这种方法是方法被调用时才初始化对象，

也叫做对象的延时加载，称为懒汉式

饿汉式只要类一加载，就已经在堆内存中创建好对象，而懒汉式在类进内存时，对象还没有

存在，只有调用了getInstance方法时，才建立对象

定义单例模式时一般使用饿汉式

 

继承

1.提高了代码的复用性

2.让类与类之间产生了关系，有了这个关系，才有了多

  态的特性

但要注意不能为了获取其他类的功能，简化代码而继承，

必须是类与类之间有所属关系才可以继承。所属关系

 

在java语言中，java只支持单继承，不支持多继承

因为多继承容易带来安全隐患；当多个父类中定义了相同功能，

但功能内容不同时子类对象不确定要用哪个。

但是java保留了这种机制，并用另一种体现形式来表示，即多实现

 

java支持多层继承，也就是一个继承体系

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系

中共性功能。通过了解共性功能，就可以知道该体系的基本功能，这样

这个体系已经可以基本使用了。

那么在具体调用时，要创建最子类的对象，这是因为有可能父类不能创建对象

（抽象类），另外创建子类对象可以使用更多的功能，包括基本的和特有的

即查阅父类功能，创建子类对象使用功能

 

子父类出现后，类成员的特点

1.变量 
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量

       
用this，子类要访问父类中的同名变量，用super

                  super的使用和this的使用几乎一致，this代表子类对象的引用，super

                 
代表父类对象的引用

2.子父类中的函数

                 
当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子

                 
类函数的内容，如同父类的函数被覆盖一样，这就是函数的另一个特性：

                 
重写（覆盖）

                 
当子类继承父类，沿袭了父类的功能到子类中，但是子类该功能的内容

                 
和父类不一致，这时没有必要定义新功能，而是使用覆盖特性，保留父

                 
类的功能定义，并重写功能内容

                 
注意：

                  1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否

                 
则失效；

                  2.静态只能覆盖静态

 

                 
重载只看同名函数的参数列表，但重写子父类方法要一模一样

 

3.子父类中的构造函数

       
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的

                 
构造函数默认第一行有一条隐藏的语句super（）；会访问父类中空参数的

                 
构造函数，。而且子类中所有的构造函数默认第一行都是super（）。

                 
子类必须访问父类中的构造函数，是因为父类中的数据子类可以直接获取，

                 
所以子类对象在建立时需要先查看父类是如何对这些数据初始化的，所以

                 
子类在对对象初始化时，要先访问以下父类中的构造函数。如果要访问父类

                 
中指定的构造函数，可以通过手动super语句来指定

                 
注意：super语句一定定义在子类构造函数的第一行。

 

                 
子类的实例化过程

                 
子类的所有的构造函数默认都会访问父类中空参数的构造函数，因为子类每

                 
个构造函数内的第一行都有一句隐式的super（）；

                 
当父类中没有空参数的构造函数，子类必须手动通过super语句形式来指定

                 
要访问父类中的构造函数；

                 
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造

                 
函数，子类中至少会有一个构造函数会访问父类中的构造函数

 

final关键字  
作为一个修饰符

1.可以修饰类、函数、变量

2.被final修饰的类不可以被继承，为了避免被继承被子类复写功能

3.被final修饰的方法不能被复写

4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员

  变量，也可以修饰局部变量

  当在描述事物时，一些数据的出现是固定的，那么为了增强阅读性

  都给这个值起个名字，方便与阅读，而这个值不需要改变，就用

  final修饰作为常量，常量的书写规范所有字母都大写，如果由多

  个单词组成，单词间通过——链接

 5.内部类定义在类中的局部位置上时，只能访问该局部被final修

   饰的局部变量

 

当多个类中出现了相同功能，但功能主题不同，这时可以进行向上抽取，只抽取

功能定义，不抽取功能主题

 

抽象类特点：

1.抽象方法一定定义在抽象类中。

2.抽象方法和抽象类都必须被abstract关键字修饰

3.抽象类不可以被new创建对象，因为调用抽象方法没意义

4.抽象类中的抽象方法要被使用，必须有子类复写其所有的抽象方法，建立子类对象调用

  如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类

 

 抽象类和一般类没有太大的不同，该如何描述事物就如何描述事物，只不过该事物中出现了

 一些看不懂的东西，这些不确定的部分，也是该事物的功能，需要明确出来，但无法明确

 主题，通过抽象方法来表示

 

 抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法

 抽象类不可以被实例化

 

 抽象类中可以不定义抽象方法，这样做仅仅是不让该类创建对象

 

接口：可以简单的理解为是一个特殊的抽象类，当抽象类中的方法都是抽

      象的，那么该类可以通过接口的形式来表示

class用于定义类，interface用于定义接口

 

接口在定义时，格式特点：

1.接口中常见定义：常量，抽象方法

2.接口中的成员都有固定修饰符；

    常量：public static final

        
方法：public abstract

        
即接口中的成员都是public的

接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接

口中的抽象方法全部覆盖后，子类才可以实例化，否则子类也是个抽象类

 

接口可以被类多实现，也是对不支持多继承的转换形式，java支持多实现

 

接口是对外暴露的规则

接口是程序的功能扩展

接口可以用来多实现

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

接口与接口之间可以有继承关系

 

Object是所有对象的直接或者间接父类。该类中定义的肯定是所有对象都具备的功能

 

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没必要重新定义，只要沿袭父类中的功能，建

立自己特有的比较内容即可，即覆盖

 

匿名内部类

1.匿名内部类其实就是内部类的简写格式

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

3.匿名内部类的格式：new
父类或者接口(){定义子类的内容}

4.其实匿名内部类就是一个匿名子类对象，而且这个对象内容较大，即带内容的对象

5.匿名内部类中定义的方法最好不要超过三个

 

内部类定义在局部时

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

2.可以直接访问外部类中的的成员，因为还持有外部类中的引用

  但是不可以访问它所在的局部变量，只能访问final修饰的局部变量

 

内部类的访问规则：

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

  之所以可以直接访问外部类中的成员，是因为内部类总持有了一个

  外部类的引用，格式：外部类名.this

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

 

访问格式：

1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中

直接建立内部类对象，格式：外部类.内部类名变量名 =
外部类对象.内部类

Outer.Inner in = new Outer().new Inner();

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

    比如，private：将内部类在外部类中进行封装

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

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

                 
在外部其他类中，访问静态内部类的非静态成员

                  new Outer.Inner().function();

                 
在外部其他类中，访问静态内部类的静态成员

                  Outer.Inner.function();

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

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

 

多态：可以理解为事物的多种体现形式

1.多态的体现

  父类的引用指向了自己的子类对象，父类的引用也可以接受自己的子类对象

2.多态的前提

  必须是类与类之间有关系，要么继承，要么实现，通常还有个前提，存在覆盖

3.多态的优势

  多态的出现提高了程序的扩展性

4.多态的弊端

  只能使用父类的引用访问父类中的成员

5.多态的应用

6.多态在代码中的特点（多态使用的注意事项）

 

在多态中成员函数的特点：

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

如果没有，编译失败

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

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

 

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

 

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

 

异常：

是对问题的描述，将问题进行对象的封装

 

异常体系

    Throwable

                  Error

                  Exception

                          RuntimeException

 

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。

                                  
也就是说可以被throw和throws关键字操作，只有异常体系具备这个特点

 

throw和throws的用法：

  throw定义在函数内，用于抛出异常对象

  throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开

 

当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败

注意，RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常，函数上

可以不用声明

 

如果函数声明了异常，调用者需要进行处理，处理方法可以throws或者try

 

异常有两种

     编译时被检测异常

                 
该异常在编译时，如果没有处理（没有抛出也没有try），编译失败

                 
该异常被标识，代表可以被处理

          运行时异常（编译时不检测）

                 
在编译时，不需要处理，编译器不检查

                 
该异常的发生，建议不处理，让程序停止，需要对代码进行修正

 

异常处理语句：

try

{

        
需要被检测的代码;

}

catch()

{

        
处理异常的代码;

}

finally

{

        
一定会执行的代码;

}

 

有三种结合格式

         try

         {}

         catch()

         {}

        

         try

         {}

         finally

         {}

 

         try

         {}

         catch()

         {}

         finally

         {}

 

注意，

1.finally中定义的通常是关闭资源代码，因为资源必须释放

2.finally只有一种情况不会执行，当执行到System.exit(0);finally不会执行

 

自定义异常

        
定义类继承Exception或者RuntimeException

         1，为了让该自定义类具备可抛性

         2，让该类具备操作异常的共性方法

 

        
当要定义自定义异常信息时，可以使用父类已经定义好的功能

        
异常信息传递给父类的构造函数

         class MyException extends Exception

         {

                  MyException(String message)

                  {

                          super(message);

                  }

         }

自定义异常：按照java的面相对象思想，将程序中出现的特有问题进行封装

 

异常的好处：

         1.将问题进行封装对象

         2.将正常流程代码和问题代码相分离，方便阅读

 

异常的处理原则：

         1.处理方式有两种：try或者throws

         2.调用到抛出异常的功能时，抛出几个就处理几个

          
一个try对应多个catch

         3.多个catch，父类的catch放在最下面

         4.catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace,输出语句

          
也不要不写。当捕获到的异常，本功能处理不了时，可以继续在catch中抛出

           try

           {

                  throw new AException();

           }

           catch(AException e)

           {

                  throw e;

           }

 

          
如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，

          
再抛出和该功能相关的异常。

          
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让

          
调用则知道并处理，也可以将捕获异常处理后，转换新的异常

           try

           {

                  throw new AException();

           }

           catch(AException e)

           {

                  //对AException处理

                  throw new BException();

           }

        

异常注意事项：

        
在子父类覆盖时：

         1.子类抛出的异常必须是父类的异常的子类或者子集

         2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛

 

1.异常：就是程序在运行时出现不正常情况

异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述

                   
并封装成对象，其实就是java对不正常情况进行描述后的对象体现

问题的划分：一种是严重的问题，一种是非严重的问题

对于严重的，java通过Error类进行描述，对于Error一般不编写针对性的代码对其处理

对于非严重的，java通过Exception进行描述，对于Exception可以使用针对性的处理方式进行处理

 

Error和Exception都是一些共性内容，比如不正常信息，引发原因等

 

Throwable

         Error

         Exception

 

2.异常的处理

  Java提供了体有的语句进行处理

  try

  {

        
需要检测的代码

  }

  catch(异常类变量)

  {

        
处理异常的代码；(处理方式)

  }

  finally

  {

        
一定会执行的语句；

  }

 

 3.对捕获到的异常对象进行常见方法操作

         String getMessage();获取异常信息

 

  在函数上声明异常，便于提高安全性，让调用处进行处理，不处理编译失败

 

对多异常的处理

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

2.对方声明几个异常，就对应几个catch块，不要定义多个多余的catch块

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

建议在进行catch处理时，catch中一定要定义具体处理方式

        
不要简单一句e.printStackTrace(),

        
也不要就简单的输出一条输出语句。

 

因为在项目中会出现特有的问题，而这些问题并未被java所描述并封装对象

所以对这些特有的问题可以按照java的对问题封装的思想，将特有的问题，进行

进行自定义的异常封装

 

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

要么在内部try catch处理，要么在函数上声明让调用者处理

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

 

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

 

一位父类已经把异常信息的操作都完成了，所以子类只要在构造时将信息传递给父类通过super

语句，那么就可以直接通过getMessage方法获得异常信息了

 

自定义异常必须是自定义类继承Exception

 

继承Exception是因为异常类和异常对象都需要被抛出，他们都具有可抛性，是throwable这个

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

 

throws和throw的区别

  throws使用在函数上，throw使用在函数内

  throws后面跟的是异常类，可以跟多个，用逗号隔开；throw后面跟的是异常对象。

 

//将自定义的问题定义成类，并且要继承Exception

class FushuException extends Exception

{

         //private String msg;

         FuShuException(String msg)

         {

                  //this.msg = new msg;

                  super(msg);

         }

         /*

         public String getMessage()

         {

                  return msg;

         }

         */

 

}

 

class Demo1

{

         int div1(int a,int b)throws FuShuException

         {

                  if(b<0)

                          throw new FuShuException("除数是负数了");//手动通过throw定义一个异常

                  return a/b;

         }

}

 

class Demo

{

         int div(int a,int b)throws ArithmeticException ,ArrayIndexOutOfBoundsException

         {                                                            //在功能上通过throws关键字声明了该功能可能出现问题

                 

                  int[] arr = new int[a];

                  System.out.println(arr[4]);

                  return a/b;

         }

}

 

class ExceptionDemo

{

         public static void main(String[] args)

         {                                                  

                  Demo d = new Demo();

                  try

                  {

                          int x = d.div(4,1);

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

                  }

                  catch (ArithmeticException e)//e就相当于：Exception e = new ArithmeticException

                  {

                          System.out.println("除数为0了");

                          System.out.println(e.getMessage());//by zero

                          System.out.println(e.toString());//异常名称：异常信息

                          e.printStackTrace();//异常名称：异常信息；异常出现的位置

                  }                                                   //其实jvm默认的异常处理机制就是调用printStackTrace

                                                                      //打印异常的堆栈的跟踪信息

                  catch (ArrayIndexOutOfBoundsException e)

                  {

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

                          System.out.println("角标越界啦");

                  }

                 

                  //int x = d.div(4,0);//除数是0
，出现问题

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

                  System.out.println("over");

         }

}

 

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

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

  异常或该异常的子类

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

3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时也不可以抛出异常

  如果子类方法发生异常，就必须进行try处理，绝对不能抛出

 

 

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