java基础

一、Hello World

   1、java的多行注释要注意
   2、写代码首先写注释，像需求、思路和步骤。

二、基本语法规则
  
   1、进制间的转化、位运算
   2、强制类型转化、类型自动提升
   3、取模的时候：%的只看左边的数，不管右边是正数还是负数。左边的数是负数的时候在结果后面加上“-”；
   4、+=： byte  a = 2;
            a=a+5;//结果会错！这一步会将a转换为int但是将int型结果赋给byte会丢失精度！
     但是：byte a=2;
            a+=5;//不会报错！没有出现类型提升的过程！
     因为第一个是两次运算：先加后赋值，第二个是一次运算就是直接赋值，因此不涉及类型转换的问题！
      
   5、foe循环的表达式不是书上的那样唯一。
   6、数组的一部分分析内存，可知 ，在java中 是将内存分为堆和栈，栈用来放临时变量，堆中放的是不同的数据结构，数组等；
                                   由此还可以看出引用数据类型和非引用数据类型的区别在于内存方式不同。数据结构还得好好体会！
       int [] arr = new int[]{2,5,52,5,}; 等同于  int [] arr= {2,5,52,5,};
      数组的两种折半算法。

三、面向对象
   
    面向对象的思想表达我的理解：物体和功能就够了。根据实际场景分析。万物皆对象。
    面向对象的特征：封装、继承和多态；
    成员变量：存在于堆内存中，因为对象的存在而存在；
    局部变量：存在于栈内存中，

    1、匿名对象：调用类的属性值没有意义，根据内存可以看出来，但调用一次类的方法十分简便。
                 可以将匿名对象作为参数进行传递。
   
    2、构造方法：作用是：对象初始化；
                 构造方法仅执行一次，是从对象创建的时候自动调用；
                 一般方法可以被调用多次，仅在对象的调用时才执行。
  
    3、构造代码块：构造代码块与构造方法的区别：构造代码块先于构造方法，构造代码块是给所有的对象使用。
                   对于那些对象们，存在共性的属性或者方法可以放在构造代码块中。
                   构造代码块是对所有的对象进行初始化；构造方法是对指定对象进行初始化。

四、

     this 关键字
  
    this就是一个对象，是要分析具体是哪一个对象。
    this关键字可以出现在实例方法和构造方法中，但不可以出现在类方法中。
    this关键字出现在类的构造方法中，代表使用该构造方法所创建的对象。
              出现在实例方法中，代表正在调用该方法的当前对象。
    当成员函数中定义了和成员变量中相同的变量时，引用成员变量要用this；
    构造函数中调用同一个类的其他构造函数时用this，放在第一行因为初始化要先执行，this代表同一个对象；
   

五、

    static 关键字

    可以修饰成员变量和成员方法；
    类变量仅在生成第一个对象时分配内存，所以实例对象共享一个类变量；在内存中，static修饰的成员变量，不在堆中存放；
    被分离出来了，所以在一个类中，它是独立的，可以有两种方式调用。就是方法区/数据区/共享区。
    它与类的关系密切：随着类的加载而加载，消亡而消亡（缺点：生命周期长）；先于对象的出现；之所以叫类**，原因就在这里。
  
    类方法只能访问类变量，这可以从内存分析的出来；
    实例方法可以对当前的实例变量和类变量进行操作；
    类方法中不能使用this或super关键字（因为先于对象的出现，这也是很多疑问的解答，先来后到）；这也可以从内存分析的出来；

    当功能内部没有访问到静态数据（对象特有的数据），那么该功能可以定义成静态的。
 
    工具类的使用就是static的很好体现。
    要知道有帮助文档的制作。
    静态代码块：随着类的加载而加载（运行），对类的初始化很少用；优先于主函数。
    例如：
    class staticCode{
          static{
                System.out.println("a");
          }
    }
   
    class StaticCodeDemo{
        
  static {
                System.out.println("b");
       
    }
 
  public static void main(String []  args){
            
            new StaticCode();
            new StaticCode();
 System.out.println("over");
    
 }
  
 static {
                System.out.println("c");
           }
  
 }执行结果：bca over
  解释：JVM首先加载StaticCodeDemo这个类，然后初始化类static优先于主函数，
 ，将类中的两个static执行，打印出bc，接下来执行主函数，new一个对象，
 之后，对象存在于内存中，第二句就不会再重复操作，打印出a,最后打印出over。
  

总结:static {
                System.out.println("b");
           }
        静态代码块是给类初始化的；
         {
                System.out.println("b");
           }
        构造函数代码块是给对象初始化的；是给所有的对象使用；
       staticdemo(int s) {
                System.out.println("b");
           }
        构造函数是给对应对象初始化的；

六、

  过程

       Person p = new Person("zhangdan"，7);这一句话之后所做的事情：
  
       对象初始化过程 ：

       1.因为new用到了Person.class,所以会先找到.class文件并加载到内存中；
       2.执行该类的static代码块，如果有的话，给Person.class类进行初始化。
       3.再堆内存中开辟空间，分配内存地址。
       4.在堆内存中建立对象的特有属性，并进行默认的初始化，
       5.对属性进行显示的初始化。
       6.对 对象进行构造代码块 初始化。
       7.对 对象进行 对应的构造函数初始化。
       8.将内存地址付给栈内存中的P变量。
      发现：首先是类的初始化，接下来是对象的初始化；

      对象调用成员变量和方法：
        内存被分为三块：堆、栈和方法区
     1.主函数入口，在栈中。
     2.在堆中，new对象，将非静态的成员属性加载并且初始化；
     3.在方法区,首先加载的是静态的变量和静态的方法，之后才是非静态的方法。

七、

  抽象类与接口
   
      抽象类:1、标示符abstract；
             2、抽象方法必须存在于抽象类中；
             3、抽象类不能被new创建对象，因为没有意思；
             4、抽象类的方法必须要有子类全部实现，实现部分方法该子类依然是抽象类，使用abstract。
       特殊:在定义类的时候将其抽象，类体中不定任何抽象方法。有用，只听说过，没见过。
 
     接口:最初理解，抽象类中的方法都是抽象方法，就将其定义为特殊的类，为接口。
          java的单继承会带来安全隐患，原因就是因为其他类中的方法会有相同，但是在接口中的方法都是空的，就不会出现这种隐患了，
          接口就很好的解决了单继承的弊端，但是，不叫继承叫实现，实现接口的类毋庸置疑要将接口中的方法全部实现。 
八、
    设计模式
   
    java有23种设计模式；
    之一：
    单例设计模式：解决一个类在内存只存在一个对象。
  
    例子:
         问题，保证对象的唯一性：
         1.为了避免其他程序过多的建立该类对象。先禁止其他程序建立该类对象；
         2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象；
         3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式；  
         解决，
         1.将构造函数私有化；
         2.在类中创建一个本类的对象；
         3.提供一个方法可以获取到该对象；
    实例：饿汉式
       class  Single{
          private int num;
          public void setNum(int num){this.num=num;}
          public int getNum(){return num;}
          private Single(){}
          private static Single s= new Single();
          public static Single getInstance(){ return s;} 
      }

   
        class singleDemo{
              public static void main(String [] args){
                     Single s1 = single.getInstance();
        Single s2 = single.getInstance();

                     s1.setNum(23);
             System.out.println(s2.getNum());

            }
      }
 运行结果为32，证明 s1和s2共用一个内部对象，实现了只操作一个对象的想法，
               注意这里面涉及的一些关键字。