8.21.javaSE复习

oop: Oriented Object Programming
  1.掌握 面向对象 基础知识
        什么是面向对象?
             是一种编程思想，我们生活中解决方式是
             面向过程，程序中是面向对象
             面向对象 遇到一个问题先不考虑如何解决，先在问题域中
             寻找具体事物，映射成对象，在根据对象 构建 类的结构
             然后在创建类的 实例 ，调用方法和 属性 ,最终解决问题;
             
        类和对象的关系?
             具体事物--->对象，
             但是对象是根据 类构建的，所以一定是现有类
             才能有对象，
             类和对象的关系:
                  类是对象的 抽象
                  对象是类的 具体实例
        在java中如何定义一个类?  一个 .java文件中可以有几个类?
             可以有多个类， 但是用public 修饰的类 只能有一个
          public class 类名{
          
          }
        
        类的结构:   一个类中可以有多个 构造块儿， 多个 游离块儿
                       创建对象时，会有限加载静态块儿，在加载游离块儿
                       静态块儿值加载一次，因为static修饰了，
                       游离块儿根据 new 对象的次数执行
             1.静态块儿 static{ } 
             2.构造块儿  游离块儿  {   }
           3.构造器: 
                构造方法是不是方法?     是 ，是特殊的方法，没有返回值，
                                         方法名与类名相同;
                一个类中可以有多个构造方法，这种现象就是方法的重载
                重载:方法名相同，参数列表不同(个数，顺序，类型)，与返回值无关
    
            作用: 1.给属性赋值  2. 规范对象的创建  new对象
                             
           4.方法:     
                方法在类中体现的是 功能; 一个类中可以有多个方法
                方法定义结构时有四种类型:
                     1.无返回值，无参数
                     2.无返回值，有参数
                     3.有返回值，无参数
                     4.有返回值，有参数
                     
           5.属性:
                1.成员属性; 在类中
                          private， public ，protected ，友好的
               2.局部属性; 方法中，(入参，代码块儿)
                         不可以加访问修饰符
        
  2. 面向对象的高级特性: 
           封装，继承 ，多态，抽象
           
           1.什么是封装?
                封装在程序中体现的是 将程序的代码细节隐藏起来，包装成
                对象来调用，及提供了外界使用的功能，又安全
                例如:类， 方法 都是封装的体现 , 使用private关键字
           2.什么是继承?
                继承就是一个类 使用extends 关键字继承了另一个类的过程
                又了继承就可以减少代码的冗余，提高代码复用性，
                提高程序的延展性;
                在继承中，子类继承了父类就 具有父类的所有公共资源
                但是父类 使用不了子类的 独有方法;
                
           ***在继承的特殊注意: 构造器， java中只支持单继承，但支持多重继承
                构造器不能被继承，只能被调用，
                会按构造器顺序检测，又无参数的，有限调用无参数的
                没有无参数的，调用有参数的;
                所以系统会默认无参数的， 一般情况下我们要拓展构造器
                就必须手动添加一个 无参数的 super(); 代表 调用父类的构造器
                super.eat(); 调用父类的方法，super相当于父类的对象
                
                方法的重写:  @Override
                     在继承中，子类中有与父类相同的方法名，入参，返回值
                     
         3.多态:    
              什么是多态?
                  多态的前提是 继承 ，也就是说向表现的是 
                  同一种事物的 不同中表现形式，这样可以提高
                  程序的灵活性，不会是模板代码
           
               代码中体现 多态的形式有几种?
                    |-- 作为方法的入参     public void follow(Pet pet);
                    |-- 父类引用 指向了 子类对象   Pet pet = new Dog();
                    |-- 接口 a = new 实现类(); 
                    
                    编译时类型 和 运行时类型
                      1.编译时类型是 父类类型
                      2.运行时类型是 子类类型
                      
                      如果想要调用子类独有的方法
                      我们可以使用 instanceof 关键字进行验证
                      if(pet intanceof Dog){
                            Dog dog = (Dog)pet;
                            dog.eat();
                      }            
             
             4.抽象: 
                  体现在不具体，是模板
                  在代码上体现的就是 abstract关键字
                  有抽象方法，  和  抽象类 
                    
                    有抽象方法的类 一定是抽象类
                    抽象类中 不一定有抽象方法
                  
                    抽象类 可以不可以继承 一个普通类? 
                         可以，
                  
                    抽象类的特点，跟类相比是半抽象， 可以有普通方法和 抽象方法
                      抽象类不可以创建对象，有构造器
                      那不能创建对象 ，有构造器有啥用啊?
                      使用来被子类调用的     
                  
                  接口: 完全抽象，接口不可以new对象
                       但是匿名创建对象时可以new ，
                       接口中只有属性 ，抽象方法，
                       它的存在的意义就是用来被实现的
                     
  3. 内部类:     
             |-- 普通内部类: public class Outer{ public class Inner{} }
             |-- 静态内部类: public class Outer{ static class Inner{} }
             |-- 方法内部类: public void eat(){ class Inner{} }
             |-- 匿名内部类: new 接口(){     }      ,new 抽象类(){  }
             
  4. 类和类之间的关系
         |-- 继承  extends 
         |-- 类和接口之间的关系是 实现      implements
         |-- 依赖  一个类 作为 一个方法的 入参
  一下三个 只能从语义 级别 来区分:
         |-- 关联  一个类做为另一个类的 属性
         |-- 聚合  一个类做为另一个类的 属性
         |-- 组合  一个类做为另一个类的 属性
         
  final关键字:
        final可以修饰 属性 ，方法， 类
          |-- final修饰属性必须 初始化，初始化方式有两种
                  1.= 赋值  ， 2.构造器赋值
          |-- final修饰方法 不能被重写
          |-- final修饰类 ，不能被继承        
       
  static关键字: 
      static关键字可以修饰 属性 被称为静态属性，  
                修饰方法被称为静态方法，
                
      static修饰的东西，可以使用类名.属性;
      
      只有内部类可以用 static 
      
      对象数组 Object[]: 
        对象数组中存储的是什么?     
           存储的是对象的引用 
           例如:  Person[] p = new Person[3];
                     p[0] = new Person();
                     p[1] = new Person();
                     
      单例设计模式:     
             |-- 懒汉模式
             |-- 饿汉模式