今天完成的事情：学习Java基础知识，完成JDBC代码注释

Java基础——接口与继承

重写：子类可以继承父类的对象方法，在继承后，重复提供该方法，叫做方法的重写，又叫覆盖override

多态：1  操作符的多态。  例如，+可以作为算术运算，也可以作为字符串连接

         2  类的多态。       例如， 父类引用指向子类对象

         类的多态现象：都是同一个类型，调用同一个方法，却能呈现不同的状态

         类的多态条件：父类（接口）引用指向子类对象；调用的方法有重写

抽象类：在类中声明一个方法，这个方法没有实现体，是一个“空”方法，这样的方法就叫抽象方法，使用修饰符“abstract”，当一个类有抽象方法的时候，该类必须被声明为抽象类

抽象类和接口的区别：

         1   子类只能继承一个抽象类，不能继承多个；子类可以实现多个接口

         2   抽象类可以定义public,protected,package,private，静态和非静态属性，final和非final属性

              接口中声明的属性只能是public，静态，final的

内部类：可以分为四种

         1  非静态内部类

            非静态内部类可以直接在一个类里面定义。new 外部类().new 内部类()

            此时是可以直接访问外部类的private实例属性

         2  静态内部类

      静态内部类不需要一个外部类的实例为基础。 new 外部类.静态内部类()

             因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法。除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别

         3  匿名类

             匿名类指的是在声明一个类的同时实例化它。 有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法，既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名，这样的类，叫做匿名类。

         4  本地类

             本地类可以理解为有名字的匿名类，与内部类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置；本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环等地方

Java基础——类和对象

引用：如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用

方法重载：通过一个类创建一个对象，这个过程叫做实例化，实例化是通过构造方法（又叫做构造器）实现的

构造方法：方法名和类名一样（包括大小写），没有返回类型，实例化一个对象的时候，必然调用构造方法。例如.      public class Hero() {

                               public Hero() {}

                      }

this：这个关键字，代表当前对象

        通过this关键字访问对象的属性。例如：this.name = name;

        通过this调用其他的构造方法.      public Hero(String name){

                                                           this.name = name; 

                                                     }

                                                     public Hero(String name, float hp){

                                                           this(name);

                                                           this.hp = hp;

                                                     }

传参：变量有两种类型 基本类型和类类型；参数也是变量，所以传参分为基本类型传参和类类型传参

       1。基本类型传参，在方法内，无法修改方法外的基本类型参数

       2   引用与=     Hero h = new Hero();我们管这个h叫做引用，=不再是赋值而是表示指向的意思

       3  类类型传参：类类型又叫引用，不同的引用指向同一个对象

包：package，把比较接近的类，规划在同一个包下。使用同一个包下的其他类，直接使用即可；但是要使用其他包下的类，必须import

访问修饰符：

类和类之间的关系：自身，同包子类，不同包子类，同包类，其他类

成员变量有四种修饰符：

      1  private 私有的  自身 可以访问，同包子类  不能继承，不同包子类  不能继承，同包类  不能访问，其他类  不能访问

      2  package/friendly/default  不写

自身 可以访问，同包子类  可以继承，不同包子类  可以继承，同包类  可以访问，其他类  可以访问

      3  protected  受保护的

自身 可以访问，同包子类  可以继承，不同包子类  可以继承，同包类  可以访问，其他类  可以访问

      4  public  公共的

自身 可以访问，同包子类  可以继承，不同包子类  可以继承，同包类  可以访问，其他类  可以访问

修饰符使用：

1. 属性通常使用private封装起来

2. 方法一般使用public用于被调用

3. 会被子类继承的方法，通常使用protected

4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小原则

简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。 这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了

类属性：当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性

            当一个属性被声明成类属性，那么所有的对象，都共享一个值

            与对象属性对比：不同对象的对象属性的值可能不一样，但是所有对象的类属性的值，都是一样的

类属性：又叫做静态属性

对象属性：又叫实例属性，非静态属性

访问类属性的方式：

            1  对象.类属性  teemo.copyright

            2  类.类属性  Hero.copyrigh

什么时候使用对象属性，什么时候使用类属性

      如果一个属性，每个英雄都不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的，每个对象的name都是不同的

      如果一个属性，所有的英雄都共享，都是一样的，那么就应该设计为类属性。比如血量上限，所有的英雄的血量上限都是 9999，不会因为英雄不同，而取不同的值。 这样的属性，就适合设计为类属性

类方法

         类方法：又叫做静态方法

         对象方法：又叫实例方法，非静态方法

访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问

         调用类方法：和访问类属性一样，调用类方法也有两种方式——对象.类方法和类.类方法。但是建议使用第二种 类.类方法 的方式进行，这样更符合语义上的理解。

         什么时候设计对象方法，什么时候设计类方法：如果在某一个方法里，调用了对象属性，比如

    public String getName(){

    return name;

    }

name属性是对象属性，只有存在一个具体对象的时候，name才有意义。 如果方法里访问了对象属性，那么这个方法，就必须设计为对象方法

如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法，比如

    public static void printGameDuration(){

    System.out.println("已经玩了10分50秒");

    }

printGameDuration 打印当前玩了多长时间了，不和某一个具体的英雄关联起来，所有的英雄都是一样的。 这样的方法，更带有功能性色彩

就像取随机数一样，random()是一个功能用途的方法

Math.random()

对象属性初始化：声明该属性的时候初始化；构造方法中初始化；初始化块

类属性初始化：声明该属性的时候初始化；静态初始化块

单例模式：又叫singleton模式，指的是一个类，在一个JVM里面，只有一个实例存在

      1 饿汉式单例模式：GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。GiantDragon 提供了一个public static的getInstance方法，外部调用者通过该方法获取12行定义的对象，而且每一次都是获取同一个对象。 从而达到单例的目的。

这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例

      2 懒汉式单例模式：只有在调用相应函数的时候，才会创建实例

      3 单例模式的选择：

         饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。如果在构造方法里写了性能消耗较大占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉有些卡顿

         懒汉式是延迟加载的方式，只有在使用的时候才会加载。并且有线程安全的考量。

         使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

      4 单例模式三要素：构造方法私有化；静态属性指向实例；public static的方法，返回第二步的静态属性

JDBC注释

明天计划的事情：

 Java基础——I/O和集合框架，初识mybatis，给DAO写注释

遇到的问题： 

云服务器上配置jdk，尚未行动，基础知识太多

收获：加深Java基础的了解