Java基础学习笔记

Java 继承 ：
    1：一旦调用 构造函数 就会形成一个实例化对象
    2：不允许多重继承 ，只允许多层继承 。   class a extends b,c{ } (错误  此为多重继承 )    class a extends b{ }        class c extends b{ } (正确)
                                                                   此为多层继承。 c 继承 b  继承 a   
    3:  最好继承不要超过三层  
    4：子类可以继承父类所有操作结构，但对于私有操作为隐式继承，所有的非隐式操作都为 显示继承 
    5：不允许直接访问 私有操作 ，但是可以通过方法的调用进行使用
    6：子类至少可以继续维持父类的现有操作
Java方法的复写:
    1:当写  权限  即（public  private  ） 不写属性 即默认为 default    
    2：public>default >private  （权限大小）
Java  属性覆盖： this 会先找本类  再找 父类  super 会直接找 父类
Java final  关键字：
    1： 定义的类 不能有子类  
    2：final 定义的方法不能呗覆写
    3：使用 final 定义的常量不能被修改
   4： 利用 public final static  X ； 进行定义 全局常量 的定义 常量 必须为大写
  Annotation的使用：
   1： Annotation  是一种 以注解的形式的程序开发
   2： @Ovaerride ：程序注解 帮助开发者在程序编译时 检查出程序错误（结构性注解  追加注解）
    @Deprecate 过期操作：在迭代开发时 有些地方 可能考虑不周 就需要使用 Deprecate 进行过期声明 
      @Deprecate// 老系统 继续使用 新系统用不了 （起到开发迭代 提醒的作用）
  
   @SuppressWarnings 压制警告 ： 只是让 警告信息不再出现，不骚扰你而已
 
 子类对父类进行功能扩充
                                       父类 ： Message     子类： DatabaseMessage 
Java中的多态：
      1：向上转型：   父类  弗雷实例= 子类 实例 · 自动完成转换：  （95%）   Message   mag= new  DatabaseMessage （）；
                             在调用时 看 你 new  的是 那个类  例如  new  DatabaseMessage  就为 子类向 父类转型    

                                                                             
      2：向下转型：  子类    子类实例=（子类）父类实例， 强制完成：（5%）（使用子类 特殊功能）
                                  Message  smg  = new   DatabaseMessage （）； （先向上转型  Message类型对象）；
                                    DatabaseMassage  smg1 =( DatabaseMessage)  smg ;(将  smg 转化为  DatabaseMassage 类型对象)；
    向上描述的是一些公共的特征 ，而向下描述的是子类自己特殊的定义环境。 （向下转型之前    首先的  向上转型  之后才能 进行向下转型）             
instanceof 关键字：  向下转型是一件 有安全隐患的操作，所以为了保证向下转型的正确性 ，往往需要进行判段  某个实例对象是否为某个类的对象
，就需要通过instanceof语句进行判断
       对象  instanceof  类；
                   Message  msg= new  Message();
             System.out .print(" msg  instanceof   Message")   ->   true  
                Message  smg  = new   DatabaseMessage （）
                      System.out .print(" msg  instanceof   Message")   ->   true 
                       System.out .print(" msg  instanceof   DatabaseMessage  ")   ->   true
                     在进行   向下转型时  一定要使用  instanceof  进行判断一下：
Object类：
             使用object类   可以处理所有数据：
             所有的类  都是  Object的子类。 

          Object  obj = new  int [ ]={1,2,3}      for ( int temp  :data)//  for   循环的简洁版
          获取对象信息：toString( )方法:  （1）：可以获取一个对象的完整信息  
          Message msg = new Message( );
          System.out.print ( msg.toString);//Object 类继承而来；
  
对象比较 ：equals（ ）
          （1）：确认两个对象 是否一致：
          （2）：即对象名不一样 但是内容 一样的 两个对象：
          （3）：对像比较应该是一个 类 内部封装好的 功能
          （4）：在默认情况下  是判断地址  是否相同：
 在类方法中调用 父类方法 可以用 super。父类方法名（）：

抽象类： abstract 
      1:继承的子类必须得 完成  抽象类的 抽象方法的复写；
      2：抽象类不能用 final 关键字进行 定义；
      3：抽象类里面 可以提供构造方法  允许没有抽象方法；
      4：无法 直接 new 实例化对象；
      5：static 方法永远不受 实例化对象或结构的限制 ，永远可以使用类名称进行调用；
      6 :本质上是一个加强类;

包装类：
     数据类型的转换：  
                                 String str= "123"
                                  int num= Integer.parseInt(str)  //str:必须为纯数字字符串
                                boolean 类型转化为   非 ture  都变成 flase 
     将数据类型转化为Sting  可以进行字符串连接//会产生垃圾堆积     
     也可以调用                int num=100;
                            String  str = String.valueOf(num);//可以避免 垃圾产生
 

 接口的基本定义：
     抽象类与普通类相比比较大的优势在于： 实现对子类复写方法的控制，但是在抽象类里，依然可能 会保留一些普通方法，而普通方法里面就会
涉及到一些安全与隐私的操作问题，那么就这样在开发过程之中 如果要像对外部 隐藏所有的细节，则就可以通过接口来进行描述。
     接口可以 理解为一个抽象类 ，除了抽象方法与全局常量之外 ，还可以定义普通方法；
      在Java 中 利用  interface 来定义接口：
         例如 ： 
                       interface  IMessage{
                     public  abstract  String getinfo（）；
 }

             对与接口的 使用方法：
    1： 接口需要在子类中被实现（implements） ，一个子类可以实现多个父接口：
    2： 子类（如果不是抽象类）那么一定要覆写 接口中的 全部抽抽象方法；
    3: 接口对象可以利用子类对象的向上转型进行实例化；
   clsaa impas implements IMessage{
       public String getinfo(){
   retrun " Ok" 
  }
}  

  void mian(){
  IMessage   msg =new MessageImpl();
  msg.getInfo( );
}  
    一个子类可以实现多个父接口： 
    接口是不允许继承父类的，所以绝对不是object 的子类， 但是根据分析可以发现，Messageimpl
    是object 子类 所以接口 一定可以通过object 接收 
     object    类对象可以接收所有数据类型，包括基本数据类型 ，类对象， 接口 对象 数组。
           
接口定义加强：
         接口由抽象方法 ，和全局常量组成 ，jdk1.8以后可以在接口中定义普通方法；  
        当接口被 很多类实现继承时：  需要更改 接口的 功能，要更改大量的类，则出现了 一种为了方便子类的修改，往往不会让子类直接实现接口
        ，而是在之间追加一个过渡的抽像类：   
      为了完善接口的设计缺陷 ：  可以在新加的方法中 可以用  default 编写一个公共的普通方法（所有子类都可以调用）
      接口中的 普通方法必须追加default声明 ，但是需要提醒的是，该操作属于挽救功能，不是设计的首选 
      除了 追加 普通方法 ，还可以定义 static 方法， 可以通过接口直接调用。
 
  工厂设计模式：（Factory）
          1：客户端不关注事物从哪里来 只关心能不能用。  
          2：  出现耦合的问题，的元凶就是 关键字  new ,给我们提供最原始的 实例化对象，出现耦合情况。
 代理设计：
           （1）  只涉及核心问题（业务）；
泛型的基本定义：
          1：泛型可以在编译时检测出程序的安全隐患，使用泛型技术可以是程序更加健壮， 如何解决class cast exception问题
          2：如果不设置泛型类型时，自动用object类型进行顶替
          3：泛型之中只允许设置引用类型，如果现在要操作基本类型必须使用包装类；
          4：从jdk1.7开始 泛型对象实例化可以 简化为Point <Integer>point =new Point<>( )
       
 包的作用：
    1： 在同一个目录下 不允许有相同的class文件
 package： 必须放在文件首行 、
  

Jar 命令：
        1： 当项目开发时 会产生大量的.class文件 ，那么对于这些文件的管理往往可以利用一种压缩结构的形式来 进行处理，
而这样的结构，在Java中被称为jar文件，我们可以直接用jdk 中的 jar命令
   2：对程序进行编译打包处理：
                     对程序打包编译： Javac-d. Message.java；将其打包为mldn.jar  
                                "-c ":创建一个新的jar文件
                             “-v":得到一个详细输出
                               "-f":设置要生成的jar文件，本处定义的是，mldn，jar
                                 *.jar 文件都是一个独立的程序路径，如果要想在Java程序之中使用此路径 ，则必须通过CLASSPATH 进行配置
      SET CLASSSPATH = .；然后输入路径    d:\mldndemo\mldn.jar
          4：建立 测试类 ，导入message类 并且调用方法，
           编译程序类： Java-d .TestMessage.java;
           解释程序：   Java cn.mldn.test.TestMessage
   如果此时程序编译通过之后，但是由于CLASSPATH发生了改变，类无法加载到了，则执行TestMessage类将会出现如下错误
      Exceptioninthread”main“ java.lang.NoClassDefFoundError:cn/mldn/util/Message
       出现这种前往只有一种情况：*。jar包没有配置正确