java中this.static.final关键字的定义

第七天课程

1. 关键字this,也叫做this语句
   this代表的是本类的对象引用
   this语句，this可以调用其他构造函数
   this()只能调用构造函数
2. 构造代码块，知道就行了

3. static静态
   不能修饰局部变量

   被static修饰的成员变量，被所有的对象共享
   被static修饰的成员变量，随着类的加载而加载
    非静态成员变量，跟随对象的存储
   优选于对象存在于内存
   静态的生命是最长，比对象生命要长
   被static修饰的成员变量，类变量，可以被类名直接调用,对象也可以调用静态成员变量

   被static修饰的成员函数，也可以被对象调用， 还可以被类名调用  
   被静态修饰的成员变量，成员函数，属于类的，不属于对象
   静态函数中，不能引用非静态变量。静态函数中，不可以写this，super

   总结一句话，先进内存的，不能调用后进内存的，后进内存的可以调用先进内存的

4. 静态的应用场景
   1 .当类中的成员变量，被所有对象共享的时候，推荐定义成静态变量
      注意，一般情况，这个变量值，是不会改变的
      在类中，不会变化的成员变量，定义成静态，变量名都大写

   2.静态函数，一般情况下，都不用静态函数
     什么时候用呢，当我函数，从来没有访问过类中的成员变量的时候
     建议将函数，定义为静态，不需要对象了

     class Demo
     {
    
       String name ="张三";
       static int AGE = 30;

       public static void show()
       {
       static int AGE = 40;
         sop(name+AGE);
       }
     }
     main(){
      Demo d =new Demo();
      d.show();
     }

 5. 静态代码块
    类中可以写静态代码块，首先会执行，一个类只执行一次

6 . 工具类的制作
     提供其他人员使用，保证工具是没有任何问题的
     数组工具：最大值，打印遍历，排序 ，二分查找
     javadoc -d 目标文件夹 -author -version ***.java

7. mian函数
     public static void main(String[] arr)
     {
    
     }

     public 被JVM调用，必须保证这个函数的最大权限
     static 不需要对象，直接被类名调用
     void   没有返回值
     main   主要的，重要
     唯一可以被修改的地方， args
     args 是虚拟机调用main函数的时候，传递的一个字符串类型的数组，数组的长度是0
     可以在程序运行的时候，手动传给数组一些字符串

8. 单例设计模式
    设计模式，解决生活中，开发中出现的问题才存在
    对象，在内存中的唯一性

    建立对象的时候，绝不可以去 new 创建对象
    虽然构造函数被private 外部的类是不能访问的，但是内部是不是可以访问
    在我自己的类中，建立自己的对象
    通过一个公共的访问函数，将这个对象进行返回

 

 

 

 第八天课程
1.继承
  |--继承的由来
    将类中的共性功能，进行抽取，抽取到另一个类中，使原有的类和抽取后的类发生继承关系
  |--继承的好处
    代码量在减少，复用性很高
    继承的出现，使类与类之间产生了关系，正是因为这个关系的出现，就导致了
    面向对象的第三个特征 ，多态性
 
  |--java中，只能单继承，不能多继承，但是可以实现多层继承

2. 什么时候使用继承，如果决定是否应该继承
  |-- 继承是为了解决现实生活中的问题而存在
  |-- 判断一个事物，是不是另一个事物中的一种
  |-- is a关系
  例子：
        猫，狗，老虎，哺乳动物中的一种
 猫，狗，老虎，继承哺乳动物

  |-- 不确定，一种事物，是不是另一种事物中的一种
      可以先视为可以继承，继承后，再看，子类是不是应该具有父类功能？
      如果子类可以具有父类的功能，继承有效，如果子类不可以具有父类的功能，继承无效
      class A{  function(){}  }
      Class B{  method() {} }
      class C extends B{
         method(){}
      }
      咖啡和酱油
      饮料
      {
        直接喝()
 解渴()
      }
      咖啡继承饮料
      {
        直接喝()
 解渴()
      }
      酱油继承饮料
      {
        直接喝()
 解渴(){}
      }

3. 继承的时候，子类和父类中成员特点
  |-- 成员变量的特点
    this可以区分本类对象中的成员变量和函数内的局部变量
    super可以区分本类对象中的成员变量和父类对象中的成员变量
    访问原则：
       1 . 函数的就近访问
       2 . 访问本类对象中的成员变量，使用this
       3 . 访问父类对象中的成员变量，使用super
    this表示本类对象
    super 表示，父类的存储位置
    this和super的用法很相似

  |-- 成员函数的特点
    当子类和父类出现一模一样的函数的时候，看上去，子类是覆盖了父类的方法
    当子类父类函数一模一样的时候，这就是函数的另一个特性，叫做重写，覆盖，复写 override
    子类有运行子类，子类没有运行父类

  |-- 构造函数的特点
    构造函数能否被继承,不能被继承
    构造函数存在覆盖，没有覆盖

    子类的构造函数，会先访问父类构造函数，自动的
    为什么子类会去方位父类构造函数，子类想看看父类中的成员变量是怎么初始化的
    子类中，所有的构造的函数，都会默认访问父类的空参数的构造函数
    子类构造函数第一个是super(),写了this()第一行就不是super,子类直接或者间接的访问
    父类构造函数

4. final关键字
  |--final是个修饰符，可以修饰成员变量，成员函数，修饰局部变量
  |--被final 修饰的类，是最终类，不能再派生子类
  |--被final修饰的函数，是最终函数，不能被覆盖
  |--被final修饰的变量，其实是一个常量
  |--将程序中固定不变的数据，一般都定义为final,而且一般都是静态的
     规范的写法：public final static double PI = 3.14;
     当程序中出现了固定不变的数据，必须写成final,体验出来你是新手

     private final static Single s = new Single();

5.抽象类
  |--由来，是对象共性抽取出来，但是抽出来共性已经不是很具体了，父类没有必要具体的规定
     没有方法体的方法，使用 abstract关键字修饰，表明这个是抽象方法，抽象方法必须存在于
     抽象类中，这个类也需要abstract关键字来修饰
  |--抽象类中，有抽象方法，抽象类，是不允许实例化对象，不能 new 抽象类类名();
     定义子类，继承抽象类，并覆盖抽象类中全部的抽象方法，建立子类对象
  |--子类覆盖抽象类中的全部方法，带有强制性

6. 抽象类细节
  |--抽象类有构造函数吗，有
  |--抽象类可以不定义抽象方法吗？可以，很少见，图形化界面中会涉及
  |--抽象不可以和哪些关键字同时出现
  |--final private static

  覆盖细节
   子类覆盖父类的方法，保证权限大于等于父类方法
   静态覆盖静态，开发中几乎没有静态覆盖静态

 

第九天课程
1. 接口：
  当抽象类中的方法，全部是抽象方法的时候，这时可以把该类定义成接口
  可以先期将接口理解为特殊的抽象类(接口中全部抽象方法，抽象类中可以有普通方法)

  定义方式 interface 接口名{}

2. 接口特点
  |--接口中的方法都是抽象的
  |--接口不能被实例化对象，只有子类实现了接口中的所有抽象方法后，该子类可以实例化对象
  否则该子类还是一个抽象类

3.接口中成员的特点
  |-- 成员变量
    接口中的成员变量，都有固定修饰符 public static fianl
  |-- 成员方法
    接口中的成员方法，public abstract

  |-- 共同特点，权限必须public

4. 子类实现接口
   |-- 类与类之间是继承关系，类与接口之间是实现关系 关键字 implements
   格式： 子类 implements 接口
           {
      实现全部抽象方法
    }
5. 实现和继承的区别
  类与类之间是继承，类中是可以定义非抽象方法的，类只要继承，就可以使用了
  接口中的方法全都是抽象的，必须由子类全部实现全

6. 接口的多实现
  |--类可以同时实现多个接口，并全部实现接口中的抽象方法，建立子类对象
  java将类的多继承进行了改良，同时实现多个接口，避免了安全隐患
  因为接口中没有方法体，需要子类实现，运行以子类为主
  子类可以继承一个类，并实现多个接口

  |--类是继承体系的共性内容，而接口是该体系中的扩展功能

7. 接口的思想
  |-- 生活中的实例
  |-- 接口是对外暴露的规则
  |-- 接口是功能的扩展
  |-- 降低了耦合度，提高了扩展性

8. 接口和抽象类的区别 --学员吸烟案例
  |-- 抽象类只能被单继承，接口可以多实现
  |-- 抽象类中可以定义非抽象方法，直接被子类使用
  |-- 接口中只有抽象方法，需要子类全部实现
  |-- 抽象类中定义继承体系中的共性内容
  |-- 接口中定义体系中对象的扩展功能
  |-- 接口的出现避免了单继承的的局限性
  |-- 抽象类被继承，是体现了谁是谁的一种  is a
  |-- 接口可以被实现，是体现了一种  like a关系

9. 接口中的多继承
  |-- 接口与类之间是实现关系，接口与接口之间是继承关系

10.多态
  |-- 一个事物具备的多种形态(函数就出现过多态性)
  |-- 动物，猫，狗实例
  |-- 多态性的代码体现 父类的引用指向自己的子类对象
  |-- 好处，提高的程序的扩展性，后期的维护性
  |-- 前提是子类重写父类抽象方法
  |-- 弊端：前期只能调用父类中的方法，而不能调用子类特有方法，前期不知道子类是谁

11.多态思想
  |--以前是建立对象，指挥对象做事情
     如果对象过多，指挥就麻烦了，所以找到对象的共性类型
     指挥这个共性类型就可以了

12.多态的转型
  |-- 父类引用指向子类对象时，子类被自动提升为了父类类型，向上转型
  |-- 要想使用子类的特有方法，需要进行强制类型转换 向下转型
  |-- 强制类型转换中的异常 ，类型转换异常
  |-- 多态中判断类型关键字 instanceof

13.接口和多态案例
  |-- 电脑主板中的PCI插槽
  |-- 数据库的操作

14.多态中的细节(记住结论)
  |-- 多态中成员变量
      编译时期，参考引用类型中是否有定义的变量
      运行时期，参考引用型变量
  |-- 多态中成员函数
      编译时期，参考引用类型中是否有调用的方法
      运行时期，参考对象所属的类中是否有调用的方法
  |-- 多态中静态成员函数
      编译时期，参考引用类型中是否有调用的方法
      运行时期，参考引用型变量是否有调用的方法

15.模板方法设计模式
  |-- 当功能一部分明确，一部分不明确的时候
      将不明确的地方暴露出去，延迟到子类去完成
      这就是我们解决不明确功能的思想
      这个思想就是模板方法设计模式