JAVASE基础（十一）

最新推荐文章于 2021-10-26 08:51:12 发布

fjs_43

最新推荐文章于 2021-10-26 08:51:12 发布

阅读量188

点赞数

分类专栏： java 文章标签：内部类异常体系

本文链接：https://blog.csdn.net/weixin_36412090/article/details/77201598

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、内部类

内部类: 在一个类的内部定义另外一个类，那么另外一个类则称作为内部类。

内部类的class文件名：外部类$内部类.class

成员内部类：

成员内部类的访问方式：
        方式一： 在外部类提供一个方法创建内部类的对象进行访问。

        方式二：在其他类中直接创建内部的对象进行访问。
                格式： 
                    外部类.内部类  变量名  = new 外部类().new 内部类();

        注意：静态成员内部类在其他类创建对象的格式：
                    外部类.内部类  变量名  =  new 外部类.内部类();

内部类的好处: 直接访问外部类的所有成员。

应用场景：我们在描述A事物的时候，A事物内部还维护了另外一个B事物，
而且B事物还必须要访问到A事物的成员，那么这时候我们就可以使用内部类描述B事物。

比如：人– 心脏 . 图形化界面编程

 成员内部类要注意的细节：
     1. 内部类可以直接访问外部类的所有成员。
     2. 内部类与外部类存在同名的成员时， 在内部类中默认是访问内部类的成员， 可以通过"外部类.this.成员"进行指定访问外部类的成员。
     3. 私有的成员内部类只能通过在外部类提供一个公共的方法进行访问。 在其他类无法访问。
     4.  如果一个成员内部类定义了静态的成员，那么该类也必须使用static修饰。

    疑问：为什么如果一个成员内部类定义了静态的成员，那么该类也必须使用static修饰 ???
        静态的成员变量是不依赖对象而存在的

class Outer{
    //
     String name = "外部类";

    //成员内部类
    static  class Inner{

        static  int x = 10;

        String name = "内部类";

        public void print(){
            System.out.println("这个是内部类的print方法:"+name); //默认访问时内部类，
        }
    }


    //外部类
    public void newInstance(){
        Inner inner = new Inner();
        inner.print();
    }

}


//其他类
class Demo7 
{

    public static void main(String[] args) 
    {
        /*
        Outer outer = new Outer();
        outer.newInstance();


        System.out.println("x:"+Outer.Inner.x);

        */

        //创建内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.print();
    }
}

局部内部类：在一个方法内部定义的类称作为局部内部类。

局部内部类要注意的细节：
1. 如果局部内部类要访问局部变量，那么局部变量必须使用final去修饰。

class Outer{

    public void print(){  

        final int y = 100;    // y的生命周期：执行到该语句的时候存在内存中， 方法执行完毕之后消失。

        //局部内部类
        class Inner{

            int x = 10;

            public void show(){
                System.out.println("这个是一个局部内部类的show方法.."+y); //问题：给人感觉y的生命周期被延长了。
                /*
                    解决办法：   
                        让局部内部类访问局部变量的复制品。
                */
            }
        }

        //创建一个局部内部类对象
        Inner inner = new Inner(); // Inner对象的生命周期比y的生命周期要长 
        inner.show();
    }

}

class Demo8 
{
    public static void main(String[] args) 
    {
        //System.out.println("Hello World!");
        Outer outer = new Outer();
        outer.print();
    }
}

匿名内部类：没有类名的内部类就称作为匿名内部类。

匿名内部类的好处：简化书写。

匿名内部类的使用前提：必须存在继承或者实现的关系。

注意的事项：
1. 匿名内部类只是没有类名而已，其他的一切成员都是具备的。

需求：定义一个局部内部类继承Animal，创建对象调用run方法。

abstract class  Animal{

    public abstract void run();


    public abstract void sleep();

}


class Outer{

    public void print(){
        /*
        class Fish extends Animal{

            public void run(){
                System.out.println("鱼在游...");
            }

            public void sleep(){
                System.out.println("鱼睁开眼睛睡觉...");
            }


        }
        //创建局部内部类的对象
        Fish f = new Fish();
        f.run();
        f.sleep();
        */

        //匿名内部类只是没有类名而已，其他的一切成员都是具备的。

    //多态
    Animal f = new Animal(){   //  这里创建的并不是Animal的对象，创建的是Animal的子类对象，只不过其子类目前没有类名借用了ANimal名字而已。
            //匿名内部类 的成员         

            String name;

            public  void run(){
                System.out.println("鱼在游...");
            }


            public void sleep(){
                System.out.println("鱼睁开眼睛睡觉...");
            }

        };

        f.run();
        f.sleep();

    }

}

class Demo9 {

    public static void main(String[] args) 
    {
        Outer outer = new Outer();
        outer.print();
    }
}

class Person{

    public void eat(){
        System.out.println("在吃饭..");
    }
}

interface Dao{

    public void add();
}



class Outer{

    public void print(){

        //匿名内部类的对象？？
        new Person(){  
            //匿名内部类的成员

            public void sleep(){
                System.out.println("在睡觉..");

            }

        }.eat();
    }


    //实现关系下的匿名内部类
    public void show(){
        //这里创建的不是Dao接口的对象，创建的是Dao接口实现类的对象。
        new Dao(){

            public void add(){
                System.out.println("添加成功..");
            }
        }.add();

    }
}

class  Demo10
{
    public static void main(String[] args) 
    {
        new Outer().show();
    }
}

二、异常体系Throwable

Throwable常用的方法：
1. toString() 返回的是用于描述该异常情况的类的完整类名。包名+ 类名 = 完整类名。
2. getMessage() 返回创建Throwable对象的时候传入的消息字符串的,
3. printStackTrace() 打印异常的栈信息。

class Demo11 
{
    public static void main(String[] args) 
    {
        /*
        //创建一个Throwable对象
        Throwable a = new Throwable("偶尔打喷嚏");
        System.out.println("toString:"+a.toString());  // java.lang.Throwable  返回的是用于描述该异常情况的类的完整类名。   包名+ 类名 = 完整类名。
        System.out.println("meessage:"+ a.getMessage());
        test();
        */
    }

    public static void test(){
        Throwable a = new Throwable("偶尔打喷嚏");
        a.printStackTrace();
    }
}