JAVA学习笔记之基础概念（一）

一、Java 简介:
   Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。
   由 James Gosling和同事们共同研发，并在 1995 年正式推出。后来 Sun 公司被 Oracle （甲骨文）公司收购，
   Java 也随之成为 Oracle 公司的产品
   Java分为三个体系：
      1.1、JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
      1.2、JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
      1.3、JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。
   2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，
   Java 的各种版本已经更名，以取消其中的数字 "2"：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。   

二、Java的一些特性：
   2.1、Java 语言不使用指针，而是引用。并提供了自动分配和回收内存空间;
   2.2、Java 语言是面向对象的；封装、继承、多态、
        2.2.1、提供类、接口和继承等面向对象的特性
        2.2.2、支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements
   2.3、Java语言是安全的：
        Java通常被用在网络环境中，为此，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，
        Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，
        并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。
   2.4、Java 语言是解释型的：
        Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。
        在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
   2.5、Java 是高性能的：
        与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。
   2.6、Java 语言是多线程的：
        在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：
        其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，
        其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。
        值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，
        而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。
        Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
  2.7、Java 语言是动态的：
       Java 语言的设计目标之一是适应于动态变化的环境。
       Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。
       另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
  开发环境配置参考：https://www.runoob.com/java/java-environment-setup.html
 

三、Java 基础语法
    3.1、对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
    3.2、类：类是一个模板，它描述一类对象的行为和状态。
    3.3、方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
    3.4、实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
        案例：
            访问修饰符    关键字    返回类型  方法名  string类     字符串数组
            public      static    void    main( String   []  args){}

    3.5、基本语法编写 Java 程序时，应注意以下几点：
        大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
        类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
        方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
        源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
        主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。   

    3.6、Java修饰符：像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
        访问控制修饰符 : default, public , protected, private
        非访问控制修饰符 : final, abstract, static, synchronized
        在后面的章节中我们会深入讨论 Java 修饰符。

    3.7、Java 变量 主要有如下几种类型的变量
        局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
        类变量（静态变量）：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

        成员变量（非静态变量）：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问

    3.8、数组和枚举
        例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁
        class FreshJuice{
           enum FreshJuiceSize{SMALL ,MEDIUM、 LARGE};
           FreshJuiceSize size;
        }            

        public class FreshJuiceRest{
               public static void main(String[]args){
                       Freshjuice juice=new FreshJuice();
                       juice.size=FreshJuice.FreshJuiceSize.MEDIUM;
               }
        }

    3.9、java关键字；
         private、protected、public、default、abstract、class、extends、final、implement、
         interface、naive、new、static、break、case、continue。。。；

    3.10、源文件声明规则
        3.10.1、一个源文件中只能有一个 public 类
        3.10.2、一个源文件可以有多个非 public 类
        3.10.3、源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
        3.10.4、如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
        3.10.5、如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
        3.10.6、import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
        3.10.7、类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。这些将在访问控制章节介绍。
        除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。   

四、基本数据类型
   变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间
  Java 的两大数据类型:
       4.1、 内置数据类型
             Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
                基本类型：byte 二进制位数：8
                包装类：java.lang.Byte
                最小值：Byte.MIN_VALUE=-128
                最大值：Byte.MAX_VALUE=127

                基本类型：short 二进制位数：16
                包装类：java.lang.Short
                最小值：Short.MIN_VALUE=-32768
                最大值：Short.MAX_VALUE=32767

                基本类型：int 二进制位数：32
                包装类：java.lang.Integer
                最小值：Integer.MIN_VALUE=-2147483648
                最大值：Integer.MAX_VALUE=2147483647

                基本类型：long 二进制位数：64
                包装类：java.lang.Long
                最小值：Long.MIN_VALUE=-9223372036854775808
                最大值：Long.MAX_VALUE=9223372036854775807

                基本类型：float 二进制位数：32
                包装类：java.lang.Float
                最小值：Float.MIN_VALUE=1.4E-45
                最大值：Float.MAX_VALUE=3.4028235E38

                基本类型：double 二进制位数：64
                包装类：java.lang.Double
                最小值：Double.MIN_VALUE=4.9E-324
                最大值：Double.MAX_VALUE=1.7976931348623157E308

                基本类型：char 二进制位数：16
                包装类：java.lang.Character
                最小值：Character.MIN_VALUE=0
                最大值：Character.MAX_VALUE=65535

       4.2、 引用数据类型
             在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量
             4.2.1、对象、数组都是引用数据类型。
             4.2.2、所有引用类型的默认值都是null。
             4.2.3、一个引用变量可以用来引用任何与之兼容的类型。

       4.3、java常量：在程序运行时是不能被修改的：使用 final 关键字来修饰常量，声明方式和变量类似
            虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
            字面量可以赋给任何内置类型的变量。例如：
            byte a = 68;
            char a = 'A'

       4.4、自动类型转换
            整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型
            ，然后进行运算。
            转换从低级到高级。
            低  ------------------------------------>  高
            byte,short,char—> int —> long—> float —> double
            数据类型转换必须满足如下规则：
                1. 不能对boolean类型进行类型转换。
                2. 不能把对象类型转换成不相关类的对象。
                3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
                4. 转换过程中可能导致溢出或损失精度，例如：
                5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

       4.5、强制类型转换
            1. 条件是转换的数据类型必须是兼容的。
            2. 格式：(type)value type是要强制类型转换后的数据类型 实例：
            """
               public class ForcedTypeCONVERSION{
                      public  static void main(String[] args){
                          int a=123;
                          byte b=(byte)a;
                          System.out.println("int强制类型转换为byte后的值等于"+b)
                      }
               }

               结果：int强制类型转换为byte后的值等于123
               隐含强制类型转换：
                    1. 整数的默认类型是 int。
                    2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

            """ 

五、Java变量类型：在Java语言中，所有的变量在使用前必须声明
    java语言支持的变量类型有：
        5.1、类变量（静态变量）：独立于方法之外的变量，用 static 修饰。
            5.1.1、类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
            5.1.2、无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
            5.1.3、静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量
            5.1.4、静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
            5.1.5、静态变量在第一次被访问时创建，在程序结束时销毁。
            5.1.6、与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
            5.1.7、默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。
                  变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
            5.1.8、静态变量可以通过：ClassName.VariableName的方式访问。
            5.1.9、类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。
                   如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。
        """
        public class Employee {
            //salary是静态的私有变量
            private static double salary;
            // DEPARTMENT是一个常量
            public static final String DEPARTMENT = "开发人员";
            public static void main(String[] args){
            salary = 10000;
                System.out.println(DEPARTMENT+"平均工资:"+salary);
            }
        }

        """
        5.2、实例变量：独立于方法之外的变量，不过没有 static 修饰。
             5.2.1、实例变量声明在一个类中，但在方法、构造方法和语句块之外；
             5.2.2、当一个对象被实例化之后，每个实例变量的值就跟着确定；
             5.2.3、实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
             5.2.4、实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
             5.2.5、实例变量可以声明在使用前或者使用后；
             5.2.6、访问修饰符可以修饰实例变量；
             5.2.7、实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
             5.2.8、实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
             5.2.9、 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
        """
        public class Employee{
           // 这个实例变量对子类可见
           public String name;
           // 私有变量，仅在该类可见
           private double salary;
           //在构造器中对name赋值
           public Employee (String empName){
              name = empName;
           }
           //设定salary的值
           public void setSalary(double empSal){
              salary = empSal;
           }
           // 打印信息
           public void printEmp(){
              System.out.println("名字 : " + name );
              System.out.println("薪水 : " + salary);
           }

           public static void main(String[] args){
              Employee empOne = new Employee("RUNOOB");
              empOne.setSalary(1000.0);
              empOne.printEmp();
           }
        }

        """
        5.3、局部变量：类的方法中的变量。
            5.3.1、局部变量声明在方法、构造方法或者语句块中；
            5.3.2、局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
            5.3.3、访问修饰符不能用于局部变量；
            5.3.4、局部变量只在声明它的方法、构造方法或者语句块中可见；
            5.3.5、局部变量是在栈上分配的。
            5.3.6、局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
        """
             public class Variable{
                    //类变量
                    static int allClicks=0;
                    //实例变量
                    String str = "hello world";

                    public void method(){
                        //局部变量
                        int i = 0;
                    }
             }
        """
六、Java修饰符
    6.1、访问修饰符：Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
            default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
            private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
            public : 对所有类可见。使用对象：类、接口、变量、方法
            protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
            默认访问修饰符-不使用任何关键字
            使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
          6.1.1、私有访问修饰符-private
                    私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，
                    并且类和接口不能声明为 private。
                    声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
                    Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据
                    """
                    public class  Logger{
                        //实例变量：私有访问修饰符private
                        private String format;

                        //公有方法，获取format值
                        public String getFormat() {
                            return this.format;
                        }

                        //通过此方法，设置format值
                        public void setFormat(String format){
                               this.format=format;
                        }
                    }    

                    """
          6.1.2、公有访问修饰符-public
                被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
                如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
                以下函数使用了公有访问控制：
                public static void main(String[] arguments) {
                   // ...
                }

          6.1.3、受保护的访问修饰符-protected
                protected 需要从以下两个点来分析说明：
                子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
                子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
                 protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
                 接口及接口的成员变量和成员方法不能声明为 protected 

                 protected interface Runoob{
                    //error：Illegal modifier for the interface Runoob; only public & abstract are permitted
                 }
          访问控制和继承：继承的规则：
            父类中声明为 public 的方法在子类中也必须为 public。
            父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
            父类中声明为 private 的方法，不能够被继承。    

    6.2、非访问修饰符
        6.2.1、static 修饰符，用来修饰类方法和类变量。
              """
                 public class InstanceCounter{
                    /*
                     * static修饰符用来创建类方法和类变量
                     */
                    private static int numInstance = 0;

                    //获取实例数量
                    protected static int getCount() {
                        return numInstance;
                    }

                    //对于生成的实例计数功能实现
                    private static void addInstance() {
                            numInstance++;
                    }

                    //构造函数，每次生成实例必调用
                    InstanceCounter() {
                        // TODO Auto-generated constructor stub
                        InstanceCounter.addInstance();
                    }

                    public static void main(String[] args) {
                        //print instance count
                        System.out.println("Starting with " + InstanceCounter.getCount() + " instances");

                        //通过for循环创建500个实例
                        for (int i=0;i<500;i++) {
                            new InstanceCounter();
                        }

                        System.out.println("Created " +InstanceCounter.getCount() + " instances");
                    }
                }
              """

        6.2.2、final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
               """
                  public class Test{
                      final int value = 10;
                      // 下面是声明常量的实例
                      public static final int BOXWIDTH = 6;
                      static final String TITLE = "Manager";

                      public void changeValue(){
                         value = 12; //将输出一个错误
                      }
                    }
               """
               final 方法：
                    父类中的 final 方法可以被子类继承，但是不能被子类重写。
                    声明 final 方法的主要目的是防止该方法的内容被修改。
               final 类：
                    final 类不能被继承，没有类能够继承 final 类的任何特性      

        6.2.3、abstract 修饰符，用来创建抽象类和抽象方法。
              抽象类：
                    抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
                    一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
                    抽象类可以包含抽象方法和非抽象方法。
                    """
                        abstract class Caravan{
                           private double price;
                           private String model;
                           private String year;
                           public abstract void goFast(); //抽象方法
                           public abstract void changeColor();
                        }

                    """
              抽象方法
                    抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
                    抽象方法不能被声明成 final 和 static。
                    任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
                    如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
                    抽象方法的声明以分号结尾，例如：public abstract sample(){};。
                    """
                        public abstract class SuperClass{
                            abstract void m(); //抽象方法
                        }

                        class SubClass extends SuperClass{
                             //实现抽象方法
                              void m(){
                                  .........
                              }
                        }
                    """

        6.2.4、synchronized 和 volatile 修饰符，主要用于线程的编程。
              关键字声明的方法同一时间只能被一个线程访问
              6.2.4.1、transient 修饰符:
                    序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
                    该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
                    """
                        public transient int limit = 55;   // 不会持久化
                        public int b; // 持久化
                    """

              6.2.4.2、volatile 修饰符:
                   volatile 修饰的成员变量在每次被线程访问时，
                   都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。
                   这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
                   """
                   public class MyRunnable implements Runnable{
                        private volatile boolean active;
                        public void run()
                        {
                            active = true;
                            while (active) // 第一行
                            {
                                // 代码
                            }
                        }
                        public void stop()
                        {
                            active = false; // 第二行
                        }
                   }

                   """

    6.3、instanceof 运算符
         """
            class Vehicle{}
            public class Car extends Vehicle{
                   public static void main(String[] args){
                           Vehicle a = new Car();
                           //判断a的实例是属于Vehicle
                           boolean result = a instanceof Car;
                           System.out.println(result);
                   }
            }

         """

    6.4、Java循环：while(){};  do{}while(); for()
         """
         public class Loop{
            public static void main(String[] args) {
                int x = 10;

                //while循环
                while (x<20) {
                    System.out.println("value of x:"+x);
                    x++;
                    System.out.println("\n");
                }

                //do。。。while循环
                do {
                    System.out.println("value of x:"+x);
                    x++;
                    System.out.println("\n");
                }while(x<20);

                //for循环
                for(int y =10;y<20;y++) {
                    System.out.println("value of y:"+y);
                    System.out.println("\n");
                }

                //for loop
                int [] numbers= {10,20,30,40,50};
                for (int z:numbers) {
                    System.out.println(z);
                    System.out.println(",");
                }
                System.out.println("\n");

                String [] names= {"james","larry","tom","lacy"};
                for (String name:names) {
                    System.out.println(name);
                    System.out.println(",");
                }

                /*
                 *  break 关键字
                    break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
                    break 跳出最里层的循环，并且继续执行该循环下面的语句。
                 */
                int [] t= {10,20,30,40,50};
                for (int z:t) {
                    //当t等于30时跳出循环
                    if (z==30) {
                        break;
                    }
                }
                //结果：10,20

                /*
                 * continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
                   在 for 循环中，continue 语句使程序立即跳转到更新语句。
                   在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
                 *
                 */
                int [] ps= {10,20,30,40,50};
                for (int p:ps) {
                    //当t等于30时跳出此次循环；
                    if (p==30) {
                        continue;
                    }
                }
                //结果：10，20，40，50    

            }
        }
         """
    6.5、当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
          和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象
          interface                           interface
             |     |__________|       |____________|
             |
          string       AbstractStringBuilder
                            |          |
                      StringBulider  SringBuffer
          特点：1、StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）
               2、由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类

          案例：
          """
                public class BuilderTest{
                    public static void main(String[] args) {
                        StringBuilder sb = new StringBuilder(10);

                        sb.append("runoob!");
                        //runoob!
                        System.out.println(sb);

                        sb.insert(6, "java");
                        //runoobjava!
                        System.out.println(sb);

                        sb.delete(5, 8);
                        //runoova!
                        System.out.println(sb);
                    }
                }

                /*
                 * @Override
                   public StringBuilder delete(int start, int end) {
                      super.delete(start, end);
                      return this;
                    }
                 *
                 *  @Override
                    public StringBuilder insert(int offset, String str) {
                        super.insert(offset, str);
                        return this;
                    }

                    @Override
                    @HotSpotIntrinsicCandidate
                    public StringBuilder append(String str) {
                        super.append(str);
                        return this;
                    }
                 */

          """

    6.6、Java 数组 array:用来存储固定大小的同类型元素，可重复；
         6.6.1、声明数组变量
                dataType [] arrayRefVar; //首选方法

                实例：double [] myList

                创建数组
                    Java语言使用new操作符来创建数组，语法如下：
                      arrayRefVar = new dataType[arraySize];
                    or
                      dataType[] arrayRefVar = {value0, value1, ..., valuek};

                案例代码：
                """
                    public class TestArray{
                        public static void main(String[] args) {
                            //数组大小
                            int size = 10;
                            //定义数组
                            double[] myList = new double[size];

                            myList[0] = 5.6;
                            myList[1] = 4.5;
                            myList[2] = 3.3;
                            myList[3] = 13.2;
                            myList[4] = 13.2;
                            myList[5] = 13.87;
                            myList[6] = 183.2;
                            myList[7] = 183.2;
                            myList[8] = 143.2;
                            myList[9] = 143.2;

                            //计算所有元素的总和
                            double total = 0;
                            for (int i=0;i<size;i++) {
                                total+=myList[i];
                            }
                            System.out.println("总和为："+total);

                            double [] myList2= {1.8,1.9,56,78,15};
                            double total2=0;
                            for (int j=0;j<myList2.length;j++) {
                                System.out.println(myList2[j]+" ");
                                //计算总和
                                total2+=myList2[j];
                             }    

                            //for each
                            for (double element: myList2) {
                                System.out.println("element"+element);
                            }

                            // 查找最大元素
                            double max = myList[0];
                            for (int i = 1; i < myList.length; i++) {
                               if (myList[i] > max) max = myList[i];
                            }
                            System.out.println("Max is " + max);

                        }
                    }

                """    

    6.7、Arrays类
        6.7.1、给数组赋值：通过 fill 方法。
              "public  static void fill(int [] a,int val);"

        6.7.2、对数组排序：通过 sort 方法,按升序。
              "public static void sort(Obkect[] a);"

        6.7.3、比较数组：通过 equals 方法比较数组中元素值是否相等。
              "public static boolean equals(long[] a,long[] a2);"

        6.7.4、查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
               "public static int binarySearch(Object[] a,Object key);"    

    6.8、Date
         代码案例：
                """
                import java.util.Date;
                import java.util.*;
                public class DateDemo{
                    public static void main(String[] args) {
                        Date date = new Date();
                        //b的使用，月份简称  printf 方法可以很轻松地格式化时间和日期
                        String str=String.format(Locale.US,"英文月份简称：%tb",date);
                        System.out.println(str);
                        System.out.printf("本地月份简称：%tb%n",date);
                        //B的使用，月份全称
                        str=String.format(Locale.US,"英文月份全称：%tB",date);
                        System.out.println(str);
                        System.out.printf("本地月份全称：%tB%n",date);
                        //a的使用，星期简称
                        str=String.format(Locale.US,"英文星期的简称：%ta",date);
                        System.out.println(str);
                        //A的使用，星期全称
                        System.out.printf("本地星期的简称：%tA%n",date);
                        //C的使用，年前两位
                        System.out.printf("年的前两位数字（不足两位前面补0）：%tC%n",date);
                        //y的使用，年后两位
                        System.out.printf("年的后两位数字（不足两位前面补0）：%ty%n",date);
                        //j的使用，一年的天数
                        System.out.printf("一年中的天数（即年的第几天）：%tj%n",date);
                        //m的使用，月份
                        System.out.printf("两位数字的月份（不足两位前面补0）：%tm%n",date);
                        //d的使用，日（二位，不够补零）
                        System.out.printf("两位数字的日（不足两位前面补0）：%td%n",date);
                        //e的使用，日（一位不补零）
                        System.out.printf("月份的日（前面不补0）：%te",date);  

                        System.out.println("Date:"+date);
                    }
                }

                /*
                 *
                 *  英文月份简称：Jan
                    本地月份简称：1月
                    英文月份全称：January
                    本地月份全称：一月
                    英文星期的简称：Tue
                    本地星期的简称：星期二
                    年的前两位数字（不足两位前面补0）：20
                    年的后两位数字（不足两位前面补0）：21
                    一年中的天数（即年的第几天）：019
                    两位数字的月份（不足两位前面补0）：01
                    两位数字的日（不足两位前面补0）：19
                    月份的日（前面不补0）：19Date:Tue Jan 19 22:59:14 CST 2021
                 *
                 *
                 *
                 */
                """
                

 6.8、java方法
         案例：System.out.println()，那么它是什么呢？
              1、println() 是一个方法。
              2、System 是系统类。
              3、out 是标准输出对象     

         方法优点：
            1. 使程序变得更简短而清晰。
            2. 有利于程序维护。
            3. 可以提高程序开发的效率。
            4. 提高了代码的重用性。    

         命名规则：
             1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
             2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如 testPop_emptyStack。            

                 修饰符   返回类型    方法名     形式参数
             public static int max(int num1,int unm2){
                    int result;

                    if (num1>num2){
             方法体     result = num1;
                    }else{
                       result = num2;
                    }
                    return result

             }
             """
                public class FinalizationDemo{
                    public static void main(String[] args) {
                        Cake c1 = new Cake(1);
                        Cake c2 = new Cake(2);
                        Cake c3 = new Cake(3);

                        c2=c3=null;
                        //调用Java的垃圾收集器
                        System.gc();
                    }
                }

                class Cake extends Object{
                    private int id;
                    public Cake(int id) {
                        this.id = id;
                        System.out.println("Cake Object " + id + "is created");
                    }

                    /*
                     *  protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
                        当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。
                     */
                    @SuppressWarnings("deprecation")
                    protected void finalize() throws java.lang.Throwable {
                        super.finalize();
                        System.out.println("Cake Object " + id + "is disposed");

                    }
                }

             """

    6.9、Java 流(Stream)、文件(File)和IO
         1、Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
         2、Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。
         3、一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
         4、Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中   

         一、读取控制台输入【BufferedReader】
             Java 的控制台输入由 System.in 完成。
             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  

         二、从控制台读取多字符串输入
            int read() throws IOException
            每次调用 read() 方法，它从输入流读取一个字符并把该字符作为整数值返回。 当流结束的时候返回 -1。该方法抛出 IOException。

         三、FileInputStream：  该流用于从文件读取数据，它的对象可以用关键字 new 来创建。
             InputStream f = new FileInputStream("C:/java/hello");
             也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：
             File f = new File("C:/java/hello");
             InputStream out = new FileInputStream(f);       

               序号               方法及描述
                1            public void close() throws IOException{}：关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
                2            protected void finalize()throws IOException {}： 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
                3            public int read(int r)throws IOException{} ： 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
                4            public int read(byte[] r) throws IOException{} ：个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
                5            public int available() throws IOException{}：返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。     

         四、Java中的目录
             4.1、File类中有两个方法可以用来创建文件夹：
                1、mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
                2、mkdirs()方法创建一个文件夹和它的所有父文件夹
                """
                案例：
                import java.io.File;
                public class CreateDir {
                    public static void main(String args[]) {
                        String dirname = "/tmp/user/java/bin";
                        File d = new File(dirname);
                        // 现在创建目录
                        d.mkdirs();
                    }
                }
                创建了目录：/tmp/user/java/bin

             4.2、读取目录  isDirectory()
                    import java.io.File;
                    public class DirList {
                        public static void main(String args[]) {
                            String dirname = "/tmp";
                            File f1 = new File(dirname);
                            if (f1.isDirectory()) {
                                System.out.println("目录 " + dirname);
                                String s[] = f1.list();
                                for (int i = 0; i < s.length; i++) {
                                    File f = new File(dirname + "/" + s[i]);
                                    if (f.isDirectory()) {
                                        System.out.println(s[i] + " 是一个目录");
                                    } else {
                                        System.out.println(s[i] + " 是一个文件");
                                    }
                                }
                            } else {
                                System.out.println(dirname + " 不是一个目录");
                            }
                        }
                    }

             4.3、删除目录以及文件【删除文件可以使用 java.io.File.delete() 方法】
                    import java.io.File;
                    public class DeleteFileDemo {
                        public static void main(String args[]) {
                            // 这里修改为自己的测试目录
                            File folder = new File("/tmp/java/");
                            deleteFolder(folder);
                        }

                        // 删除文件及目录
                        public static void deleteFolder(File folder) {
                            File[] files = folder.listFiles();
                            if (files != null) {
                                for (File f : files) {
                                    if (f.isDirectory()) {
                                        deleteFolder(f);
                                    } else {
                                        f.delete();
                                    }
                                }
                            }
                            folder.delete();
                        }
                    }

    6.10、Java Scanner 类
         创建 Scanner 对象的基本语法：Scanner s = new Scanner(System.in);
         并通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，
         在读取前我们一般需要 使用 hasNext 与 hasNextLine 判断是否还有输入的数据：
            import java.util.Scanner;
            public class ScannerDemo {
                public static void main(String[] args) {
                    Scanner scan = new Scanner(System.in);
                    // 从键盘接收数据

                    // next方式接收字符串
                    System.out.println("next方式接收：");
                    // 判断是否还有输入
                    if (scan.hasNext()) {
                        String str1 = scan.next();
                        System.out.println("输入的数据为：" + str1);
                    }
                    scan.close();
                }
            }   

         方法论：next() 与 nextLine() 区别
                1、next():
                    1、一定要读取到有效字符后才可以结束输入。
                    2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
                    3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
                next() 不能得到带有空格的字符串。
                2、nextLine()：
                    1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
                    2、可以获得空白。
                    如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx()    

         案例：
            package Demo1;
            import java.util.Scanner;
            public class ScannerDemo{
                   public static void main(String[]args) {
                      // 从键盘接收数据
                      Scanner scan=new Scanner(System.in);

                      //接收数据-----------------010------------
                      int i=0;
                      float f = 0.0f;
                      System.out.print("输入整数");
                      //判断输入是整数：如果是小数:hasNextFloat
                      if (scan.hasNextInt()) {
                          i=scan.nextInt();
                          System.out.println("输入整数:"+i);
                      } else {
                            // 输入错误的信息
                            System.out.println("输入的不是整数！");
                        }
                        System.out.print("输入小数：");

                      //接收数据-----------------010------------

                      //next方式接收---------------11---------------------
                      System.out.println("next方式接收：");
                      if(scan.hasNext()) {
                          String str1= scan.next();
                          System.out.println("输入的数据为：" + str1);
                          }
                      scan.close();
                      //-------------------------11-----------------------

                      //------------------------计算总和-22-------------------
                      double sum =0;
                      int m = 0;
                      while(scan.hasNextDouble()) {
                          double x=scan.nextDouble();
                          m=m+1;
                          sum=sum+x;
                      }
                      System.out.println(m + "个数的和为" + sum);
                      System.out.println(m + "个数的平均值是" + (sum / m));
                      scan.close();
                      //------------------------计算总和---22-----------------

                   }
            }
    6.11、java异常
          6.11.1、异常分类
               1、检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
               2、 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
               3、 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。        

              所有的异常类是从 java.lang.Exception 类继承的子类
                   Throwable {
                      1、Error
                      2、Exception：{
                                 2.1、IOException ；
                                 2.2、RuntimeException ；
                      }
                   }    

          6.11.2、捕获异常
                try
                {
                   // 程序代码
                }catch(ExceptionName e1)
                {
                   //Catch 块
                }
          案例：
            // 文件名 : ExcepTest.java
            import java.io.*;
            public class ExcepTest{

               public static void main(String args[]){
                  try{
                     int a[] = new int[2];
                     System.out.println("Access element three :" + a[3]);
                  }catch(ArrayIndexOutOfBoundsException e){
                     System.out.println("Exception thrown  :" + e);
                  }
                  System.out.println("Out of the block");
               }
            }     

          6.11.3、throws/throw 关键字：如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。
          案例：
                import java.io.*;
                public class className
                {
                  public void deposit(double amount) throws RemoteException
                  {
                    // Method implementation
                    throw new RemoteException();
                  }
                  //Remainder of class definition
                }  

          6.11.4、finally关键字
                 finally 关键字用来创建在 try 代码块后面执行的代码块。
                 无论是否发生异常，finally 代码块中的代码总会被执行。
                  public class ExcepTest{
                      public static void main(String args[]){
                        int a[] = new int[2];
                        try{
                           System.out.println("Access element three :" + a[3]);
                        }catch(ArrayIndexOutOfBoundsException e){
                           System.out.println("Exception thrown  :" + e);
                        }
                        finally{
                           a[0] = 6;
                           System.out.println("First element value: " +a[0]);
                           System.out.println("The finally statement is executed");
                        }
                      }
                  }
          6.11.5、声明自定义异常
                    在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
                    所有异常都必须是 Throwable 的子类。
                    如果希望写一个检查性异常类，则需要继承 Exception 类。
                    如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
                    可以像下面这样定义自己的异常类：
                    class MyException extends Exception{
                    }  

                    案例：
                        import java.io.*;

                        //自定义异常类，继承Exception类
                        public class InsufficientFundsException extends Exception
                        {
                          //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
                          private double amount;

                          public InsufficientFundsException(double amount)
                          {
                            this.amount = amount;
                          } 

                          public double getAmount()
                          {
                            return amount;
                          }
                        }            

          6.11.6、通用异常
                  在Java中定义了两种类型的异常和错误。
                  JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
                  程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。    

                  案例：
                  """
                    //文件名称 CheckingAccount.java
                    import java.io.*;

                    //此类模拟银行账户
                    public class CheckingAccount
                    {
                    //balance为余额，number为卡号
                    private double balance;
                    private int number;
                    public CheckingAccount(int number)
                    {
                       this.number = number;
                    }
                    //方法：存钱
                    public void deposit(double amount)
                    {
                       balance += amount;
                    }
                    //方法：取钱
                    public void withdraw(double amount) throws
                                               InsufficientFundsException
                    {
                       if(amount <= balance)
                       {
                          balance -= amount;
                       }
                       else
                       {
                          double needs = amount - balance;
                          throw new InsufficientFundsException(needs);
                       }
                    }
                    //方法：返回余额
                    public double getBalance()
                    {
                       return balance;
                    }
                    //方法：返回卡号
                    public int getNumber()
                    {
                       return number;
                    }
                    }

                  """
                  文件2
                  """
                    public class BankDemo
                    {
                       public static void main(String [] args)
                       {
                          CheckingAccount c = new CheckingAccount(101);
                          System.out.println("Depositing $500...");
                          c.deposit(500.00);
                          try
                          {
                             System.out.println("\nWithdrawing $100...");
                             c.withdraw(100.00);
                             System.out.println("\nWithdrawing $600...");
                             c.withdraw(600.00);
                          }catch(InsufficientFundsException e)
                          {
                             System.out.println("Sorry, but you are short $"
                                                      + e.getAmount());
                             e.printStackTrace();
                          }
                        }
                    }

                  """