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("换电脑或者放假");
         }

     }

 }