学习第三周

class Person{
    String name;
    int age ;
    public void eat(){
        System.out.println("吃饭");
    }

    public void method(){
       //局部内部类
       class AA{

       }
    }

    {
        //局部内部类
        class BB{

        }
    }
    public Person(){
        //局部内部类
       class CC{

       }
    }

    //成员内部类
    //静态成员内部类
   abstract static class Brian{
        String name;
        public Brian(){

        }
        public void think(){
            System.out.println("think");
        }
    }
    //非静态成员内部类
    class legs{
        String name;
        public legs(){

        }
        public void walk(){
            System.out.println("walk");
            Person.this.eat();//调用外部类的属性（非静态）
        }

    }
}

关注以下三个问题：

1 、如何实例化成员内部类的对象

   public class InnerClassTest {
    public static void main(String[] args) {
        //创建Brain实例（静态的成员内部类）
        Person.Brain brain = new Person.Brain() {
            @Override
            public void think() {
                super.think();
            }
        };
        //创建legs实例（非静态成员内部类）
        Person p = new Person();
        Person.legs leg = p.new legs();
        leg.walk();
    }
}
class Person{
    String name;
    int age ;
    public void eat(){
        System.out.println("吃饭");
    }

    public void method(){
       //局部内部类
       class AA{

       }
    }

    {
        //局部内部类
        class BB{

        }
    }
    public Person(){
        //局部内部类
       class CC{

       }
    }

    //成员内部类
    //静态成员内部类
   abstract static class Brain{
        String name;
        public Brain(){

        }
        public void think(){
            System.out.println("think");
        }
    }
    //非静态成员内部类
    class legs{
        String name;
        public legs(){

        }
        public void walk(){
            System.out.println("walk");
            Person.this.eat();//调用外部类的属性（非静态）
        }

    }
}

2、如何在成员内部类中区分调用外部类的结构

3、开发中局部内部类的使用

 public Comparable getComparable(){

         //创建一个实现了Comparable接口的类
         //方式一：
//         class MyComparable implements Comparable{
//
//             @Override
//             public int compareTo(Object o) {
//                 return 0;
//             }
//
//         }
//         return new MyComparable();

//         //方式二：
//         return new Comparable() {
//             @Override
//             public int compareTo(Object o) {
//                 return 0;
//             }
//         };
//     }

}

异常：

定义：

Java语言中，将程序执行中发生的不正常的情况称为“异常”

Error：

Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况，易班不编写针对性代码进行处理。

Exception：

其他因编程错误或偶然的外在因素导致一般性问题，可以使用针对性的代码进行处理。例如：

*空指针访问

*试图读取不存在的文件

*网络链接中断

*数组角标越界

异常体系结构：

常见的异常：

1、运行时异常

import java.util.Scanner;
public class ExceptionTest {
    //NullpointerException  空指针
//    public void test1(){
//        int []arr = null;
//        System.out.println(arr[3]);
//    }
    //数组角标、字符串越界
   public void test2(){
       //数组越界
//        int [] arr = new int[10];
//        System.out.println(arr[10]);
       //字符串越界
//       String str = "abc";
//       System.out.println(str.charAt(3));
//
  }

    //类型转换异常


    //NumberFormatException
//    public void test4(){
//       String str = "123";
//       int num = Integer.parseInt(str);
//    }
    //InputMismatchException
//    public void test5(){
//       Scanner scanner = new Scanner(System.in);
//       int score  = scanner.nextInt();
//       System.out.println(score);
//    }
    //ArithmeticException
//    public void test6(){
//       int a = 10;
//       int b = 0;
//       System.out.println(a/b);

//    }

}

2、编译时异常

异常处理：抓抛模型

“抓”：

方法一：try-catch-finally

格式：

try{

//可能出现异常的代码

}catch(异常类型1 变量名1){

//处理异常的方式

}catch(异常类型2 变量名2){

//处理异常的方式

}catch(异常类型3 变量名3){

//处理异常的方式

}

......

finally{

//一定会执行的代码

}

说明：1、finally是可选的

2、使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配

3、一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理，一旦处理完成就跳出当前的try--catch结构（没有写finally的情况），继续执行其后的代码。

4、catch中的异常类型如果没有子父类关系，则谁声明在下，谁声明在上无所谓，如果有子父类关系，则要求子类必须声明在父类上方。

5、异常对象处理的方式：

> String getMessage( )

> printStackTrace( )

6、在try结构中声明的变量在出了try结构之后不能再调用

7、try--catch--finally结构可以嵌套

在使用try--catch--finally处理编译时异常，是使程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try--catch--finally将一个编译时可能出现的异常延迟到运行时出现

finally 说明：

finally是可选的
finally中声明的是一定会被执行的代码，即使catch中又出现了异常，try、catch中有return语句

方法二：throws+异常类型

1、使用

“throws+异常类型”写在方法的声明除，指明此方法执行是，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在一场的代码出生成一个异常类的对象，此对象满足throws后异常类型时就会被抛出

2、体会：

try--catch--finally：真正的把异常处理掉了

throws只是将异常抛给了方法的调用者，并没有真正的将异常处理掉

如何选择try--catch--finally还是throws？

3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着子类重写的方法中又一场，必须使用try--catch--finally方式处理。

3.2 在执行方法中，先后又调用了另外几个方法，这几个方法时递进关系执行的，我们建议这几个方法使用throws的方式进行处理，而执行的方法A可以考虑使用try--catch--finally进行处理。

lulu想学敲代码

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
学习第三周

目录接口的使用定义接口与类的关系如何定义接口，接口中的成员在Java开发中，接口都通过让类去实现（implements）的方式来使用Java类可以实现多个接口（多实现）创建接口匿名实现类对象注意内部类定义内部类分类成员内部类一方面：作为外部类的成员：另外一方面：作为类：关注以下三个问题：1 、如何实例化成员内部类的对象2、如何在成员内部类中区分调用外部类的结构3、开发中局部内部类的使用异常：定义Err...
复制链接

扫一扫