黑马程序员——java学习5（107-126）——内部类,异常,包

1、内部类

1.1何时：

事物的内部还有事物，就用内部类（人体和心脏举例）

方法：

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

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

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

格式：

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

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

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

private,static等,当内部类被静态修饰后，只能访问外部类中的static成员

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

当外部类中的静态方法访问内部类时，内部类必须为静态。（静态不建实例已存在）

面试:

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

new Outer.Inner().function();

在外部其他类，如何访问static内部类的静态成员

Outer.Inner.function();

package learn;
class Outer{
private int x=3;
class Inner{//内部类
int x=4;
void function(){
int x=5;
System.out.println("inner"+x);
System.out.println("inner"+this.x);
System.out.println("inner"+Outer.this.x);
}
}
void method(){
Inner in=new Inner();
in.function();
}
}
public class InnerClassDemo {
public static void main(String[] args) {
Outer out=new Outer();
out.method();
//内部类非私有时可如下访问
Outer.Inner Inn=new Outer().new Inner();
Inn.function();
}
}

1.2.内部类定义在局部时

不可以被成员修饰符修饰(static)

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

package learn;

class Outer{
    int x=3;
    void method(){
        class Inner{
            void function(){
                //内部类调用外部类的成员变量
                System.out.println(Outer.this.x);
            }
        }
        //非静态类，没对象不运行
        new Inner().function();
    }
}
public class InnerClassDemo3 {
    public static void main(String[] args) {
        new Outer().method();
    }
}

(2)但是不可访问他所在的局部中的变量，只能访问被final修饰的局部变量

package learn;

class Outer3{
    int x=3;
    void method(){
        final int y=4;
        class Inner{
            void function(){
                //内部类访问它所在的局部中的变量，必须为final
                System.out.println(y);
            }
        }
        //非静态类，没对象不运行
        new Inner().function();
    }
}
public class InnerClassDemo3 {
    public static void main(String[] args) {
        new Outer3().method();
    }
}

1.3、匿名内部类

就是内部类的简写

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

何时：使用过的方法的参数是匿名内部类，且其中方法不超过3个

如:public static void show(Inner in)可换成如下:

show(new Inter

{

　　public void method(){

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

}

});

格式：new父类/接口(){定义子类的内容}

其实匿名内部类就是匿名子类对象，可以理解为带内容的对象

匿名对象调用方法只可调用一次，且不可调用自己的方法，最好别超过3个

package learn;

abstract class AbsDemo{
    abstract void show();
}

class Outer4{
    int x=3;
//    class Inner4 extends AbsDemo{
//        void show(){
//            System.out.println("show"+x);
//        }
//    }
//    public void function(){
//        new Inner4().show();
//    }
//    
    public void function2(){
    //AbsDemo d=new AbsDemo()也可以
    new AbsDemo(){
        void show(){
            System.out.println("show"+x);
        }
            
    }.show();
    
    }
}
    
public class InnerClassDemo4 {
    public static void main(String[] args) {
//        new Outer4().function();
        new Outer4().function2();
    }
}

package learn;
interface Inter{
    void method();
} 
class Test{
    static class Inner implements Inter{
        public void method(){
            System.out.println("1");
        }
    }
    static Inter function(){
//        return new Inner();//内部类
        //匿名内部类
        return new Inter(){
            public void method(){
                System.out.println("1");
            }
    };
}
}
public class InnerClassDemo5 {
    public static void main(String[] args) {
        //倒推
        Test.function().method();
        //Test类中有个静态方法function，
        //.method:function方法运算后的结果是一个对象，而且是一个Inner类型的对象
        //因为只有Inner类型的对象，才可以调用method方法
    }
    
}

2、异常

异常也是一类对象，表示现实生活中的具体的事物

问题分为严重和非严重

严重的是Error类

error不编写针对性的代码对其进行处理

非严重的是Exception类描述

编写针对性的代码

好处：

（1）将问题进行封装

（2）将正确流程代码和问题代码相分离，便于阅读

2.1处理过程:

try{

　　需要被检测的代码

}

catch(异常类 变量){

　　处理异常的代码

}

finally{

　　一定会执行的语句

}

对捕获到的异常对象的常见方法操作

package learn;
class Demo{
    int div(int a,int b)
    {
        return a/b;
    }
}

public class ExceptionDemo {
public static void main(String[] args) {
    Demo d=new Demo();
    try
    {
        int x=d.div(4, 0);   //new Exception()
        System.out.println("x="+x);
    }
    catch(Exception e)//Exception e=new Exception()
    {
        System.out.println("除零了");
        System.out.println(e.getMessage());//  /byzero详细消息的字符串
        System.out.println(e.toString());//异常名称:异常信息
        e.printStackTrace();//打印堆栈中的跟踪信息,异常名称，异常信息，异常出现的位置
        //其实jvm默认的异常处理机制就是在调用printStackTrace方法
    }
}
}

2.2、异常声明方法，throws Exception

一开始声明，告诉这里可能会出错,便于提高安全性，让调用出进行处理，不处理编译失败。内部解决了（有catch）可以不声明

class Demo{
    int div(int a,int b)throws Exception//在功能上通过throws关键字声明了该功能可能出现问题
    {
        return a/b;
    }
}

2.3、多异常处理

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

(2)、对方声明几个异常，对应有几个catch块

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面（不然它会解决所有能解决的问题，使问题笼统为一个名字）

(3)、一定要定义具体处理方式，别定义e.printStackTrace();也别书写一条输出语句

2.4、自定义异常

为了显示出异常信息，自定义类继承Exception,因为父类中把异常信息的操作都完成了，所以子类在构造时，将传递给父类通过super语句。

就可以直接通过父类的getMessage方法获取自定义的异常信息了。

继承Exception是因为异常体系的一个特点，异常类和异常对象都被抛出，他们具备可抛性，这个可抛性是Throwable这个体系中独有特点，只有这个体系的类和对象才可被throw和throws操作

package learn;
class FuShuException extends Exception{
    private int value;
    FuShuException(){
        super();
    }
    FuShuException(String msg,int value){
        super(msg);
        this.value=value;
    }
    public int getValue(){
        return value;
    }
}
class Demo3{
    int div(int a,int b)throws Exception{//函数上
        if(b<0)
            //函数内
            throw new FuShuException("出现了除数是负数的情况，",b);//手动通过throw关键字抛出一个自定义异常
        return a/b;
    }
}

class ExceptionDemo3{
    public static void main(String[] args){
        Demo3 d=new Demo3();
        try
        {
            int x=d.div(4, -1);   
            System.out.println("x="+x);
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
            System.out.println("除数变负数");
        }
        System.out.println("over");
    }
}

//// 1,2推出3,
//class Throwable{
//    private String message;           //3
//    Throwable(String message)
//    {
//        this.message=message;         //2
//    }
//    public String getMessage(){
//        return message;               //1
//    }
//}
//
//class Exception extends Throwable{
//    Exception(String message)
//    {
//        super(message);
//    }
//}

2.5、throws和throw

throws使用在函数上,后面跟的异常类。可以跟多个。用逗号隔开    //int div(int a,int b)throws FuShuException{

throw使用在函数内,后面跟的是异常对象

2.6、特殊的异常RuntimeException

函数内抛出异常，函数上不用声明

函数上声明异常，调用者可以不处理

因为希望程序停止，被修改，问题不被隐藏

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

总结：

异常分两种

(1)、编译时被检测的异常，必须声明

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

2.7、finally

执行一定要做的动作，一般用于关闭资源

try+catch（可多个catch）; try+catch+finally; try+finally

只有当系统执行到System.exit(0);finally才不会执行

2.8、异常在子父类覆盖中的表现:

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

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

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

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

PS:视频123练习四※

3、包

封装的体现

让java和class文件分离存放

javac -d . PackageDemo.java//在当前路径下创建包并把class文件放进去

set classpath=包的父目录，不需进入包

3.1、包与包之间

类，被访问的成员，都要public

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

包与包之间可以使用的权限:

　　　　　　public> protected> default> private

同一个类中　　ok　　　　ok　　　　ok　　　　ok

同一个包中　　ok　　　　ok　　　　ok　　　　

子类　　　　　ok　　　　ok　　　　

不同包中　　　ok

一个java文件中不能出现两个以上的共有类或接口

3.2、导入import

导入的是路径下的文件，不包含目录中文件下的的文件

建议用url定义包名

java pack.PackageDemo//需指定包