Java 学习 day09

01-面向对象(内部类访问规则)

package myFirstCode;

/*
内部类的访问规则：
1. 内部类可以直接访问外部类的成员，包括私有private。
    之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式 外部类名.this----//Outer.this.x
2. 外部类要访问内部类，必须建立内部类对象。
 */

class Outer
{
    private int x = 3;
     class Inner //内部类
     {
         void function()
         {
             System.out.println("inner : "+Outer.this.x);//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 in = new Outer().new Inner();//面试会问到，实际不会使用
//        in.function();
    }

}

02-面向对象(静态内部类)

package myFirstCode;

/*  // 不做重点掌握
内部类的访问规则：
1. 内部类可以直接访问外部类的成员，包括私有private。
    之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式 外部类名.this----//Outer.this.x
2. 外部类要访问内部类，必须建立内部类对象。

访问格式：
1. 当内部类定义在外部类的成员位置上，而且非私有，可以在外部类其他类中。
可以直接建立内部类对象。
格式
    外部类名.内部类名 变量名= 外部类对象.内部类对象
    Outer.Inner in = new Outer().new Inner();//面试会问到，实际不会使用

2. 当内部类在成员位置上，就可以被成员修饰符所修饰。
    比如，private：将内部类在外部类中进行封装。
        static：内部类就具备static的特性。
        当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
        
        在外部其他类中，如何直接访问静态内部类的非静态成员呢？
        new Outer.Inner().function();
        
        在外部其他类中，如何直接访问静态内部类的静态成员呢？
        Outer.Inner().function();//使用频率很低
        
    注意：当内部类中定义了静态成员，该内部类必须是static的。
 */

class Outer
{
    private int x = 3;
    static class Inner //静态内部类出现次数不多
     {
         void function()
         {
             System.out.println("inner : "+x);
         }
     }
     
     void method()
     {
         Inner in = new Inner();
         in.function();
     }
}

public class InnerClassDemo {

    public static void main(String[] args)
    {
//        new Outer.Inner().function();
        Outer.Inner.function();
        //直接访问内部类中的成员。
//        Outer.Inner in = new Outer().new Inner();//面试会问到，实际不会使用
//        in.function();
    }

}

03-面向对象(内部类定义原则)

package myFirstCode;

/*  // 不做重点掌握
内部类的访问规则：
1. 内部类可以直接访问外部类的成员，包括私有private。
    之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式 外部类名.this----//Outer.this.x
2. 外部类要访问内部类，必须建立内部类对象。

访问格式：
1. 当内部类定义在外部类的成员位置上，而且非私有，可以在外部类其他类中。
可以直接建立内部类对象。
格式
    外部类名.内部类名 变量名= 外部类对象.内部类对象
    Outer.Inner in = new Outer().new Inner();//面试会问到，实际不会使用

2. 当内部类在成员位置上，就可以被成员修饰符所修饰。
    比如，private：将内部类在外部类中进行封装。
        static：内部类就具备static的特性。
        当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
        
        在外部其他类中，如何直接访问静态内部类的非静态成员呢？
        new Outer.Inner().function();
        
        在外部其他类中，如何直接访问静态内部类的静态成员呢？
        Outer.Inner().function();//使用频率很低
        
    注意：当内部类中定义了静态成员，该内部类必须是static的。
        当外部类中的静态方法访问内部类时，内部类也必须是static的。
        
当描述事务时，事务的内部还有事务，该事务用内部类来描述，
因为内部事务在使用外部事务的内容。

class Body
{
    private class XinZang
    {
        
    }
    
    public void show()
    {
    new XinZang().
    }
 */

class Outer
{
    private int x = 3;
    static class Inner //静态内部类出现次数不多
     {
         void function()
         {
             System.out.println("inner : "+x);
         }
     }
     
     void method()
     {
         Inner in = new Inner();
         in.function();
     }
}

public class InnerClassDemo {

    public static void main(String[] args)
    {
//        new Outer.Inner().function();
        Outer.Inner.function();
        //直接访问内部类中的成员。
//        Outer.Inner in = new Outer().new Inner();//面试会问到，实际不会使用
//        in.function();
    }

}

04-面向对象(匿名内部类)

package myFirstCode;
 /*
匿名内部类：
1. 匿名内部类其实就是内部类的简写格式。
2. 定义匿名内部类的前提：
    内部类必须是继承一个类或者实现接口。
3. 匿名内部类的格式：new 父类或接口(){定义子类的内容}
4. 匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。
5. 匿名内部类中定义的方法最好不要超过3个。
  */
abstract class AbsDemo
{
    abstract void show();
}

class Outer4
{
    int x = 3;
//    class Inner extends AbsDemo
//    {
//        void show()
//        {
//            System.out.println("show :"+ x);
//        }
//        void abc()
//        {
//        System.out.println("haha");
//        }
//    }
    public void function()
    {
//        new Inner().show();
        
        AbsDemo d = new AbsDemo()//匿名子类对象
        {
            void show()
            {
                System.out.println("show :"+ x);
            }
            void abc()
            {
                System.out.println("abc");
            }
        };
        d.show();
        //d.abc();//编译失败，转不了;
    }
}

class InnerClassDemo4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Outer4().function();
    }

}

package myFirstCode;

interface Inter5
{
    void method();
}

class Test5
{
    //补足代码。通过匿名内部类。.
    /*
    static class Inner implements Inter5
    {
        public void method()
        {
            System.out.println("method run");
        }
    }
    
        static Inter5 function()
        {
            return new Inner();
        }*/
    
    static Inter5 function()
    {
        return new Inter5()
        {
            public void method()
            {
                System.out.println("method run");
            }
        };//要记得加分号
}
}

class InnerClassTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //Test.function():Test 类中有一个静态的方法 function。
        //.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
        //因为只有是Inter类型的对象，才可以调用method方法。
        
        Test5.function().method();
        Inter5 in = Test5.function();
        in.method();
    }

}

05-面向对象(异常概述)

package myFirstCode;

/*
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事务，也可以通过Java的类的形式进行描述。并封装成对象。
        其实就是Java对不正常情况进行描述后的对象体现。
        
对于问题的划分:两种：一种是严重的问题，一种非严重的问题。

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

对于非严重的，Java通过Exception类进行描述
    对于Exception可以使用针对性的处理方式进行处理。
    
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

Throwable
    |--Error
    |--Exception
 */

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

public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d = new Demo();
        int x = d.div(4, 0);
        System.out.println("x="+x);
        System.out.println("over");
    }

}

06-面向对象(异常try-catch)

package myFirstCode;

/*
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事务，也可以通过Java的类的形式进行描述。并封装成对象。
        其实就是Java对不正常情况进行描述后的对象体现。
        
对于问题的划分:两种：一种是严重的问题，一种非严重的问题。

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

对于非严重的，Java通过Exception类进行描述
    对于Exception可以使用针对性的处理方式进行处理。
    
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

Throwable
    |--Error
    |--Exception
    
2. 异常的处理
 java提供了特有的语句进行处理。
 try
 {
     需要被检测的代码;
 }
 catch(异常类 变量)
 {
     处理异常的代码;(处理方式)
 }
 finally
 {
     一定会执行的语句;
 }
 
3. 对捕获到的异常对象进行常见方法操作。
    String getMessage(); 获取异常信息
 */

class Demo6
{
    int div(int a,int b)
    {
        return a/b;
    }
}

public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo6 d = new Demo6();
        try {
            int x = d.div(4, 0);
            System.out.println("x="+x);
        } catch (Exception e)   // Exception e = new ArithmeticException();
        {
            System.out.println("除零啦");
            System.out.println(e.getMessage());  //  /by zero
            System.out.println(e.toString());  // 异常名称：异常信息
            e.printStackTrace();  // 异常名称，异常信息，异常出现的位置。
                                // 其实jvm默认的异常处理机制，就是在调用printStackTrace方法
                                //    打印异常的堆栈的跟踪信息。
        }

        System.out.println("over");
    }

}

07-面向对象(异常声明throws)

package myFirstCode;

/*
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事务，也可以通过Java的类的形式进行描述。并封装成对象。
        其实就是Java对不正常情况进行描述后的对象体现。
        
对于问题的划分:两种：一种是严重的问题，一种非严重的问题。

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

对于非严重的，Java通过Exception类进行描述
    对于Exception可以使用针对性的处理方式进行处理。
    
无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

Throwable
    |--Error
    |--Exception
    
2. 异常的处理
 java提供了特有的语句进行处理。
 try
 {
     需要被检测的代码;
 }
 catch(异常类 变量)
 {
     处理异常的代码;(处理方式)
 }
 finally
 {
     一定会执行的语句;
 }
 
3. 对捕获到的异常对象进行常见方法操作。
    String getMessage(); 获取异常信息
    

4. 

 */

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

public class ExceptionDemo1 {

    public static void main(String[] args) //throws Exception 
    {
        Demo7 d = new Demo7();

        int x;
        try {
            x = d.div(4,0);
            System.out.println("x="+x);
        } catch (Exception e) 
        {
            System.out.println(e.toString()); 
        }


        System.out.println("over");
    }

}

08-面向对象(多异常处理)

package myFirstCode;

/*
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事务，也可以通过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(),
也不要简单的就书写一条输出语句。

 */

class Demo7
{
    int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException,Exception //在功能上通过throws的关键字 声明了该功能有可能会出现问题。
    {
        int[] arr = new int[a];
        
        System.out.println(arr[4]);
        return a/b;
    }
}

public class ExceptionDemo1 {

    public static void main(String[] args) //throws Exception 
    {
        Demo7 d = new Demo7();

        int x;
        try {
            x = d.div(4,0);
            System.out.println("x="+x);
        } 
        catch(Exception e)
        {
            System.out.println("hahaha ："+e.toString());
        }
/*
        catch (ArithmeticException e) 
        {
            System.out.println(e.toString()); 
            System.out.println("被零除了"); 
        }
        catch (ArrayIndexOutOfBoundsException e) 
        {
            System.out.println(e.toString()); 
            System.out.println("角标越界啦"); 
        }
*/

        System.out.println("over");
    }

}

09-面向对象(自定义异常)

package myFirstCode;

/*
因为项目中会出现特有的问题。
而这些问题并未被Java所描述并封装对象。
所以对于这些特有的问题可以按照Java的对问题封装的思想。
将特有的问题，进行自定义的异常封装。

自定义异常。


需求：在本程序中，对于除数是负数-1，也视为是错误的，是无法进行运算的。
     那么就需要对这个问题进行自定义的描述。
     
当在函数内部出现了throw抛出异常对象，那么就必须给出对应的处理动作。
要不在内部try catch处理。
要不在函数上声明 让调用者处理。

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

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

如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。


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

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都需要被抛出。
他们都具备可抛性。这个可抛性是throwable这个体系中的独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。
 */
class FuShuException extends Exception //getMessage();
{
    private int value;
    
    FuShuException(String msg,int value)
    {
        super(msg);
        this.value = value;
    }
    public int getValue()
    {
        return value;
    }
}

class Demo8
{
    int div(int a,int b) throws FuShuException
    {
        if(b<0)
            throw new FuShuException("出现了除数是负数的情况----- /By fushu",b); // 手动通过throw关键字抛出一个自定义异常对象。
        return a/b;
    }
}

public class ExceptionDemo1 {

    public static void main(String[] args) //throws Exception 
    {
        Demo8 d = new Demo8();
        try 
        {
            int    x = d.div(4,-1);
            System.out.println("x="+x);
        } 
        catch (FuShuException e) 
        {
            System.out.println(e.toString());
            //System.out.println("除数出现负数了");
            System.out.println("错误的负数是："+e.getValue());
        }

        System.out.println("over");
    }

}

/*
class Throwable
{
    private String message;
    Throwable(String message)
    {
        this.message = message;
    }
    public String getMessage()
    {
        return message;
    }
}

class Exception extends Throwable
{
    Exception(String message)
    {
        super(message);
    }
}
*/

10-面向对象(throw和throws的区别)

throws和throw的区别：
throws使用在函数上。（小括号和大括号之间）（）***{}
throw使用在函数内。

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

11-面向对象(RuntimeException)

package myFirstCode;

/*
Exception中有一个特殊的子类异常RuntimeException 运行时异常。

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

如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过。

之所以不用函数上声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，系统停止程序后，
对代码进行修正。

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

对于异常分两种：
1、 编译时被检测的异常。
2. 编译时不被检测的异常（运行时异常，RunTimeExceptiong以及其子类）。
 */

class Demo9
{
    int div(int a,int b) //throws ArithmeticException
    {
        if(b==0)
            throw new ArithmeticException("被零除啦");
        return a/b;
    }
}

public class ExceptionDemo4 {

    public static void main(String[] args) //throws Exception 
    {
        Demo9 d = new Demo9();
        int x = d.div(4, 0);
        System.out.println("x="+x);

        System.out.println("over");
    }

}

12-面向对象(异常练习)

package myFirstCode;

/*
 毕老师用电脑上课。

 开始思考上课出现的问题。

 比如问题是：电脑蓝屏。
 电脑冒烟。

 要对问题进行描述，封装成对象。

可是当冒烟发生后，出现讲课进度无法继续。

出现了讲师的问题：课时计划无法完成。
 */
class LanPingException extends Exception {
    LanPingException(String message) {
        super(message);
    }
}

class MaoYanException extends Exception {
    MaoYanException(String message) {
        super(message);
    }
}

class NoPlanException extends Exception
{
    NoPlanException(String message) {
        super(message);
    }
}

class Computer {
    private int state = 3;

    public void run() throws LanPingException, MaoYanException {
        if (state == 2)
            throw new LanPingException("蓝屏啦");
        if (state == 3)
            throw new MaoYanException("冒烟啦");
        System.out.println("电脑运行");
    }

    public void reset() {
        state = 1;
        System.out.println("电脑重启");
    }
}

class Teacher {
    private String name;
    private Computer cmpt;

    Teacher(String name) {
        this.name = name;
        cmpt = new Computer();
    }

    public void prelect() throws NoPlanException 
    {
        try {
            cmpt.run();

        } catch (LanPingException e) {
            cmpt.reset();

        } catch (MaoYanException e) {
            test();
            throw new NoPlanException("课时无法继续"+e.getMessage());//throw 存在，下面不要有语句
        }
        System.out.println("讲课");
    }
    public void test()
    {
        System.out.println("练习");
    }
}

class ExceptionTest {

    public static void main(String[] args) {
        Teacher t = new Teacher("毕老师");
        try 
        {
            t.prelect();
        } 
        catch (NoPlanException e) 
        {
            System.out.println(e.toString());
            System.out.println("换电脑或者放假");
        }

    }

}