JAVASE学习笔记第9天

面向对象（内部类访问规则）（不常用，但是面试）

1、内部类的访问规则：

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

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

l  外部类要访问内部类，必须建立内部类的对象。

2、内部类创建对象的格式：

       外部类名.内部类名 对象名 = new 外部类名（）.new 内部类名（）；

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

3、示例：

class Outer

{

       private int x=3;

      

       //内部类

       class Inner

       {

              void function()

              {

                     System.out.println(x);

              }

       }

}

 

class Demo

{

       public static voidmain(String[] args)

       {

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

              a.function();

       }

}

 

面向对象（静态内部类）（不常用，但是面试）

1、访问规则：

l  当内部类在成员的位置上，并且不是private

格式：

外部类名.内部类名 变量名= new 外部类名（）.内部类名();

 

 

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

例如：private :将内部类封装在外部类中

      static : 被satic修饰后只能访问外部类中的static成员。

                       

在外部其他的类中，如何直接的访问static内部类的非静态成员呢?

new Outer.Inner() .function();

//这句的意思是Outer.Inner是因为内部类是静态的

//然后创建内部类的对象，从而调用内部类中的非静态的方法。

 

在外部的其他的类中，如何直接的访问static内部类中的静态的成员呢?

Outer.Inner.functionn();

 

注意：内部类中更有静态的，则该内部类也是static

面向对象（内部类定义规则）（程序设计）

1、一般什么时候定义内部类？

当描述事物的时候，事物内部还有事物，那么就可以定义内部类。

通常情况下，是因为内部类和外部列之间有密切的交互练习。

一般我们会把内部类封装起来，对外提供访问的方法。

 

面向对象（匿名内部类）

匿名内部类：

1、匿名内部类其实就是内部类的简化格式。

2、定义匿名内部类的前提：

内部类必须继承一个类或者实现接口

3、匿名内部类的格式：new 父类或者接口名(){定义子类内容} （其实就是构造函数+子类内容，一般不超过三个方法）

4、其实匿名内部类就是一个子类对象，而且这个对象有点胖，可以理解为带内容的子类对象。

5、匿名内部类中定义的方法最好不要超过3个。

注意：在awt那块常用。

 

 

示例1：将内部类改写成匿名内部类：

改写之前：

abstract class Abc

{

       abstractvoid show();

}

 

class Outer

{

      

       intx =3;

/*

       classInner extends Abc

       {

              voidshow()

              {

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

              }

       }

*/

 

       publicvoid method()

       {

              //newInner().show();

 

       }

}

 

改写之后：

abstract class Abc

{

       abstractvoid show();

}

 

class Outer

{     

       intx =3;

 

       publicvoid method()

       {

              //使用匿名内部类

              newAbc()

              {

                     voidshow()

                     {

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

                     }

              }.show();

       }

}

 

class InnerDemo

{

       publicstatic void main(String[] args)

       {

              Outerout =new Outer();

              out.method();

       }

}

 

2、（面试）补足代码

 

/**

需求：补足代码

interface Inter

{

       voidmethod();

}

 

class Test

{

       //补足代码，通过匿名内部类

}

 

class InnerTest

{

       publicstatic void main(String[] args)

       {

              Test.function().method();

       }

}

 

分析：

Test.function().method();

这句话等同于：

Test.function :说明function是静态的

.method():说明function返回的是一个对像。

所以这句话可以等同于

Inter in =Test.function;

in.method();

*/

 

 

interface Inter

{

       publicabstract void method();

}

 

class Test

{

       //补足代码，通过匿名内部类

       staticInter function()

       {

              returnnew Inter()

              {

                     publicvoid method()

                     {

                            System.out.println("methodrun");

                     }

              };

       }

}

 

class InnerTest

{

       publicstatic void main(String[] args)

       {

              Test.function().method();

       }

}

 

面向对象（异常概述）

1、异常的由来：

问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。

2、问题的划分可以分为两种：一种是严重问题，一种是非严重问题。

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

在java中通过Exception类描述非严重的问题，可以使用针对性的方法进行处理。

3、异常体系：

Throwable

l  Error:

l  Exception

 Error和Exception的子类类名都是以父类作为后缀。

 

 

面向对象（异常处理try{}catch(){}）

1、/**

异常的处理：

格式：

 

try

{

       需要被检测的代码         

}

catch(异常类 变量名)

{

       处理异常的代码

}

finally

{

       一定执行的语句

}

*/

 

class Demo

{

       publicint div(int a,int b)

       {

              returna/b;

       }

}

 

class ExceptionDemo

{

       publicstatic void main(String[] args)

       {

              Demod =new Demo();

              try

              {            

                     intx=d.div(4,0);

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

              }

              catch(Exception e)

              {

                     System.out.println(e.getMessage());// 错误信息： / by zero

                     System.out.println(e.toString()); //异常名称错误信息 ：java.lang.ArithmeticException:/ by zero

                     e.printStackTrace();

                     //错误名称错误的信息 出错位置

                     /*

                     java.lang.ArithmeticException:/ by zero

          at Demo.div(ExceptionDemo.java:23)

          at ExceptionDemo.main(ExceptionDemo.java:34)

                 其实JVM在处理默认的异常处理机制，就是调用printStackTrace方法，

                 即打印异常中的堆栈中的跟踪信息

                     */

              }

              System.out.println("over");

       }

}

面向对象（异常声明throws）

1、异常的处理方式有两种：一种是声明、一种是处理。（也就是一个是抛一个是接）

2、一般我们在开发的时候，觉得自己的代码有问题会先声明有异常，然后把问题丢给调用者，从而提高安全性。

3、例子：

class Demo

{

public int div(int a,int b) throws Exception //声明异常

{

        return a/b;

}

}

 

classExceptionDemo2

{

public static void main(String[] args) //抛出异常 throws Exception

{

        Demo d =new Demo();

        //调用div方法，首先得解决异常，有两种处理方式：一种是抛出异常，一种是处理异常

        //接收异常

        try

        {

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

               System.out.println(x);

        }

        catch (Exception e)

        {

               e.printStackTrace();

        }

        System.out.println("ole");

}

}

面向对象（多异常处理）

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

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

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

3、在catch处理时，catch块中的内容一定要有具体的处理方式。

class Demo

{

       publicint div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException//具体

       {

              int[]arr=new int[a];

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

              returna/b;

       }

}

 

class ExceptionDemo2

{

       publicstatic void main(String[] args)

       {

              Demod =new Demo();

             

              //抛出几个，有几个catch块

              try

              {

                     intx =d.div(5,0);

                     System.out.println(x);

              }

              catch(ArithmeticException e)

              {

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

                     System.out.println("除以0了");

              }

              catch(ArrayIndexOutOfBoundsException e)

              {

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

                     System.out.println("数组越界了");

              }

 

              System.out.println("ole");

       }

}

面向对象（自定义异常类）（不是很熟悉）

1、为什么自定义异常信息呢？

因为在开发项目的时候出现了特有的问题，而这些问题在java的异常中没有具体的描述，这时候，我们就可以自定义异常。

2、对于自定义的异常需要手动的处理。

3、注意：当在函数的内部出现了throw抛出异常对象，那么就必须要给出对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。

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

4、切记：自定义的异常一定会继承Exception

5、继承Exception的原因：

异常体系有一个特点：无论是异常类还是异常对象都具有可抛性。

也只有这个体系中的类和对象才能够被throw和throws操作。

6、例子：

/**

需求：除数是负数就是异常。

分析：因为java中本身不存在着解决的方式，所以自定义异常

*/

 

classFuShuException extends Exception

{

private int x ;

FuShuException(int x)

{

        this.x = x;

}

 

public void getValue()

{     

        System.out.println(x);

}     

}

 

class Demo

{

public int div(int a,int b)throwsFuShuException

{

        //手动抛出异常对象,用throw

        if(b<0)

               throw new FuShuException(b);

        return a/b;

}

}

 

classExceptionDemo3

{

public static void main(String[] args)

{

        Demo d =new Demo();

        try

        {

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

               System.out.println(x);

        }

        catch (FuShuException e)

        {

               e.getValue();

        }

       System.out.println("hhha");

       

}

}

 

面向对象（throw和throws的区别）

1、throw和throws的区别：

l  throws使用在函数上

l  throw使用在函数内

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

l  throw后面跟的是异常对象。

 

面向对象（RuntimeException）

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

 

 

 

2、RuntimeException的特点：

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

Ø  如果在函数上声明了该异常，调用者可以不进行处理。

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

4、对于异常分为两种：

Ø  编译时被检测的异常

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

5、例子：

 

//编译时异常

classFuShuException extends RuntimeException

{

FuShuException(String msg)

{

        super(msg);

}

}

 

class Demo

{

int div(int a,int b)

{

        if(b==0)

               throw newArithmeticException("被0除了"); //函数不用声明

        if(b<0)

               throw new FuShuException("被负数除了");  //函数不用声明

 

        return a/b;

}

}

 

classExceptionDemo4

{

public static void main(String[] args)

{

        Demo d =new Demo();

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

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

}

}

 

 

 

面向对象（异常练习）

/**

需求：老师用电脑上课，（中途电脑可能蓝屏可能冒烟）

分析：名词提炼法

*/

 

//蓝屏问题

class LanPingException extends Exception

{

       LanPingException(Stringmsg)

       {

              super(msg);

       }

}

 

//冒烟问题

class MaoYanException extends Exception

{

       MaoYanException(Stringmsg)

       {

              super(msg);

       }

}

 

//课时无法完成问题

class NoPlanException extends Exception

{

       NoPlanException(Stringmsg)

       {

              super(msg);

       }

}

 

/*

电脑

*/

class Computer

{

       privateint x =3;

       //运行

       publicvoid run()throws LanPingException,MaoYanException

       {                          

              if(x==2)

                     thrownew LanPingException("电脑蓝屏了");

              if(x==3)

                     thrownew MaoYanException("电脑冒烟了");

              System.out.println("电脑运行");

       }

 

       //重启

       publicvoid restart()

       {

              System.out.println("电脑重启");

       }

}

 

//老师

class Teacher

{

       privateString name;

       privateComputer com;

 

       Teacher(Stringname)

       {

              this.name=name;

              com=newComputer();

       }

      

       //做练习

       publicvoid lianXi()

       {

              System.out.println("做练习");

       }

 

       //讲课,有课出现问题

       publicvoid teach()throws NoPlanException

       {

              try

              {

                     com.run();

              }

              catch(LanPingException e)

              {

                     com.restart();

              }

              catch(MaoYanException e)

              {

                     lianXi();

                     thrownew NoPlanException("无法正常上课"+e.toString()); 

              }

             

              System.out.println("讲课");

       }

 

 

}

 

//学长

class ExceptionTest

{

       publicstatic void main(String[] args)

       {

              Teachert=new Teacher("laobi");

              try

              {

                     t.teach();

              }

              catch(NoPlanException e)

              {     

                     System.out.println("放假"+e.toString());

              }

      

       }

}