java超强学习笔记(一)

0

java超强学习笔记(一)

配置java环境变量：
 JAVA_HOME：配置JDK的目录
 CLASSPATH：指定到哪里去找运行时需要用到的类代码（字节码）
 PATH：指定可执行程序的位置
 
 LINUX系统（在" .bash_profile "下的环境变量设置）
  JAVA_HOME=/opt/jdk1.5.0_06
  CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
  PATH=$PATH:$JAVA_HOME/bin:.
  export JAVA_HOME CLASSPATH PATH     (将指定的环境变量声明为全局的)
   
 windows系统：
  右击我的电脑-->属性-->高级-->环境变量
  
Java的运行过程：
 编译：生成可执行文件，如C++中利用g++生成a.out，效率高，但不跨平台
 解释：解释器把源文件逐行解释，跨平台但效率不高
 
 在java中：先编译后解释，把.java文件编译成.class字节码文件
  Java源代码文件(.java文件)--->
  Java编译器(javac)--->
  Java字节码文件(.class文件，平台无关的)--->
  Java解释器(java)，执行Java字节码

Java的垃圾回收：
 由一个后台线程gc进行垃圾回收
 虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收
 缺点：不能够精确的去回收内存
 java.lang.System.gc(); 建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收
 内存中什么算是垃圾：
  不在被引用的对象(局部变量，没有指针指向的)
  
java的安全性：
 沙箱机制：只能做沙箱允许的操作
 通过下面环节，实现安全
  加载有用的类文件，不需要的不加载
  校验字节码，查看允许的操作
   查看代码和虚拟机的特性是否相符
   查看代码是否有破坏性
   查看是否有违规操作，如越界
   查看类型是否匹配，类型转换是否能正确执行
   
源程序：
 package mypack;  //相当于一个目录
 
 public class HelloWorld{
  public static void main(String[] args){
   System.out.println(“Hello World”);
  }
 }
 注：
  1、文件名必须和public修饰的类名一致，以.java作为文件后缀，如果定义的类不是public的，则文件名与类名可以不同。
  2、一个.java文件中可以有多个class，但是只有一个public修饰的类。
  3、java源代码文件编译后，一个类对应生成一个.class文件
  4、一个java应用程序应该包含一个main()方法，而且其签名是固定的，它是应用程序的入口方法，可以定义在任意一个类中，不一定是public修饰的类
  编译：javac -d . HelloWorld.java
   含有包的类，在编译的时候最好用上面的格式，-d指的是让该类生成的时候按照包结构去生成，" . "指的是在当前路径下生成
   如果不用上面的格式，也可以用javac HelloWorld.java，但是需要注意的是包结构就要由自己去建立，然后将生成的.class文件放到该目录下
  执行：java mypack.HelloWorld
   将字节码文件交给Java虚拟机去解释执行
   需要注意的事，必须使用包名.类名去解释执行
   
包(package)：把源文件放在目录下
 由于工程的需要，将不同的源文件放在不同的目录下，从而引入了包。
 包可以看作就是一个存放java源文件的目录。
 在源码中声明一个包名：package p;(只能放在第一行，且最多只能是一行)
 如果指定多层包，那么在包名之间我们可以用.作为分隔符：package p1.p2.p3.p4;
 用“javac HelloWorld.java –d 绝对路径”，编译后生成的字节码文件就会放在指定的包结构下
 执行该程序需要用" java 包名.类名 "
 引进包中的某个类：import 包名.类名;
 引进包中的所有类：import 包名.*;
   
注释：
 // 单行注释， 到本行结束的所有字符会被编译器忽略
 /* */ 多行注释，  在/*  */之间的所有字符会被编译器忽略
 /**  */   文档注释， java特有的，在/**  */之间的所有字符会被编译器忽略
 可以用javadoc把java源程序中这种注释抽取出来形成html页面(只有写在包，类，属性，方法，构造器，引入之前的注释才可以进行抽取)
    
标识符：
 命名规则：
  (1) 由字母、数字、下划线、$组成，不能以数字开头
  (2) 大小写敏感
  (3) 不得使用java中的关键字和保留字
 
 关键字：都是小写的，jdk1.2多了strictfp(经准浮点型)，关键字 jdk1.4多了assert(断言)关键字，  jdk1.5多了enum(枚举) 关键字
  随着学习进度，会慢慢接触到的
  true、false、null严格说不应该算关键字，应称其为保留字更合适
 
 习惯：
  (1) 标识符要符合语义信息
  (2) 包名所有字母小写
  (3) 类名每个单词首字母大写，其它小写 //TarenaStudent
  (4) 变量和方法：第一个单词小写，从第二个单词开始首字母大写 //tarenaStudent
  (5) 常量：所有字母大写，每个单词之间用" _ "连接
  
基本数据类型：8种
 1) 整型
  byte       1B  8位       -128到127
  short      2B  16位      -2^15到(2^15)-1
  int          4B  32位      -2^31到(2^31)-1
  long        8B  64位      -2^63到(2^63)-1
 2) 浮点类型
  float        4B   32位      
  double     8B   64位
 3) 字符类型
    char       2B 16位  
 4) 布尔型  1B
  boolean    false/true
  
 注：
  1、Java中的自动类型提升问题。
   1)、正向过程：从低字节到高字节可以自动转换。
    byte->short->int->long->float->double
   2)、逆向过程：从高字节到低字节用强制类型转换。
    例：int a = (int)4.562；
    注：逆向转换将丢失精度。
   2、boolean：只有true和false。
   3、char：Java中用" u四位十六进制的数字 (即使在注释中出现u，后面如果跟的不是4个数字，也会报错)"表示将字符转换成对应的unicode编码，字符类型要用单引号括起来。
   4、黙认浮点类型为double，float数据类型有一个后缀为" f "或" F "。
   5、long类型有一个后缀，为" l " 或者" L "
 
引用数据类型：
 类、接口、数组
 引用类型 变量名 = new 引用类型名(参数);  //new后面一般跟的都是类的构造器
 成员：写在类体括号里面的
 
内存空间的分配：
 内存分为：
  栈：存放简单数据类型变量(值和变量名都存在栈中)，存放引用数据类型的变量名以及它所指向的实例的首地址
  堆：存放引用数据类型的实例

局部变量：不是声明在类体括号里面的变量
 (1)必须要先赋值，后使用，否则通不过编译，局部变量没有默认初始化值
 (2)作用范围：定义开始到定义它的代码块结束
 (3)同一范围内，不允许2个局部变量命名冲突

 参数传递时，简单类型进行值转递 (参数进行传递时都会先去栈中生成一个副本的，使用结束后释放)
 
自动类型提升：
 byte a = 1;
 byte b = 2;
 a = a+b;          //编译出错自动类型提升成int
 a += b;       //自加没有自动类型提升问题
 类型自动提升规则：
  a和b作某种运算
  a和b中有double，结果就是double
  a和b中有float，结果就是float
  a和b中有long，结果就是long
  除此之外，结果都是int
 把高字节转成低字节,需要作强制类型转换. byte c=(byte)a+b;
 
移位运算符：效率最高
 >>   有符号右移，补符号位
  移负数位，则将该数值加32后再进行移位
  数值的2进制是按照补码保存的
 >>>  右移后高位都补0
 
逻辑运算符：
 &/|也可以作为逻辑运算符
 && 先判断前面一个条件，如果为假，则不用计算后一个条件
 || 先判断前面一个条件，如果为真，则不用计算后一个条件
 
" + "运算符：
 两个操作的对象是数值时，是加法
 如果有一个是字符串时，则是字符串的连接
 
流程控制语句：
 同Core C++
 switch中的变量类型只能是byte、 short、int、char四种类型
 
数组：
 声明数组：  
  数组能以下列形式声明：
   类型[] array;
   类型 array[]; 
  注：
   JAVA中推荐用：类型[] array;
   一个数组是一个对象
   声明一个数组没有创建一个对象
   声明时不用指定长度
   
 创建数组：
  创建基本数据类型数组：int[] i = new int[2];
  创建引用数据类型数组：Student[] s = new Student[100];
  数组创建后其中的元素有初始值
   类型                     黙认值
   byte                      0
   short                     0
   int                       0
   long                      0l
   float                     0.0f
   double                   0.0d
   char                      u0000
   boolean                 false
   reference types     null
  注：
   创建时一定要指定长度
   int[] i2=new int[];            //error
   
 初始化数组：
  声明、创建、初始化分开：
   int[] i;   //定义数组
   i = new int[2];  //分配空间
   i[0] = 0;    //初始化
   i[1] = 1;
   
  声明、创建、初始化在同一时间 ：
   int[] i = {0,1};   //显示初始化  {}中有几个值,则数组长度为几
   Student[] s = {new Student(),new Student()};
   
  注： int[] i=new int[]{1,2,3};      //后面[]中不可以写数值
   int[] i1=new int[3]{1,2,3};    //error
   
 二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组)
  int[][] i1 = new int[2][3];
  int[][] i4 = {{1,1,1},{2,2,2},{3,3,3}};
  int[][] i3 = new int[][3];  //不允许高维没分配空间而先给低维分配空间
  int[][] i2 = new int[2][];
  i2[0] = new int[2];
  i2[1] = new int[3];    
  
 数组长度：
  数组的属性length
  数组长度一旦确定,不可改变    
  int[] i = new int[5]; 则i.length= 5
  
 数组拷贝：
  系统类System提供的
  static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
   src： 源数组  
   srcPos： 从源数组哪个位置开始拷贝(位置指的是元素的下标)
   dest： 目标数组
   destPos： 拷贝的元素放到目标数组的起始位置
   length： 拷贝多少个
   
 数组排序：
  自己实现一个排序方法来进行排序
  或者调用java.util.Arrays.sort(Object o)

类和对象：
 类：主观抽象，是对象的模板，可以实例化对象
  习惯上类的定义格式：
   package xxx;  
   import xxx;  
   public class Xxxx{
    属性 ······;
    
    构造器 ······;
    
    方法 ······;
   }

  定义属性：实例变量
   格式：[ 修饰符 ]  类型 变量名  [ = ? ]
   实例变量定义在类中但在任何方法之外。
   实例变量有默认值：各种各样的0。(同数组)
   实例变量的作用域至少在本类内部，受访问控制符的限制。
   在重合作用域，实例变量和局部变量允许有命名冲突，“局部优先”。
   
  定义方法：
   格式： [ 修饰符 ]  返回类型 方法名( 参数列表 ) [ throws  异常 ] { ······ }
   java中所有参数都是值传递。
      当没有值返回时，返回类型必须被定义为void。
   返回类型必须与方法名相邻，其他修饰符可以调换位置。
   
  构造器：
   在创建对象的过程中调用的方法。
   构造器没有返回类型。
   构造器的名字与类名相同。
   格式为：[ 修饰符 ]  类名( 参数列表 ){  }，修饰符可以是private、 protected、 default、private
   在一个对象的生成周期中构造器只用一次，由系统自动调用，不允许手工调用。
   程序员没有提供一个构造器，系统会自动提供一个无参的构造器。
   获得对象的方式：
    通过new（在堆空间中申请分配空间），new 类名()，可以通过这种形式或的一个对象，这时的对象是无法使用，必须把他的地址存放进一个对象变量才能够使用。
    例如 ：
     Car c=new Car();
   注意：
    最好在写类时提供一个无参的构造器。
      
  this关键字：
   this是个隐式参数，代表当前对象;
    publie class Student{
     private String name;
     public void setName(String name){
      this.name=name;  //this.name为当前对象的成员变量
     }
    }
    
   如果某个构造方法的第一个语句具有形式this( ··· )，那么这个构造方法将调用同一类中的其他构造方法。
   
          注意：
           在构造器中this(...)必须放在该构造器的第一行。
    this不能出现在静态方法里面  
 
 类、对象、实例三者的关系：
  类：是对象的模板，可以实例化对象
  对象：类的个体
  实例：实现的对象
  student s; 
  s=new student();
   其中 Student为类，s为对象，new Student()为实例，s赋值后也是实例了。

方法重载：
 方法名相同，参数表不同，不考虑返回值类型(但最好还是使返回类型一致)。
 编译器根据参数，选择一个方法，如果没有完全匹配的，对于参数表采用“向上就近匹配原则”，但不允许模棱两可。
 方法重载屏蔽了一个对象的同一类方法由于参数不同所造成的差异。
   
封装：
 类的属性加private修饰符，来限制只能够在类的内部进行访问，有效的保护数据。
 对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操作的安全性。
 方法公开的是方法的声明，即只须知道参数和返回值就可以调用该方法，隐藏方法的实现的细节。
 一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。
  
继承：
 父类到子类是从一般到特殊的关系。
  泛化：将不同子类中的共性抽象成父类的过程。
  特化：在原有父类的基础上加入一些个性的过程。
  原则：父类放共性，子类放个性。
 继承的关键字：extends
 Java只支持单继承：一个类最多只有一个直接的父类。

      方法覆盖：
  方法名：相同
  参数表：相同
  访问限制符：相同或者更宽
  返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0以后）
  抛出的异常：不能比父类更宽。
    
      super关键字：
  super()表示调用父类的构造器
  super()也和this()一样必须放在方法的第一句
  super()和this()不能同时出现        
  super可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性
  在子类的构造器中如果没有指定调用父类的哪一个构造器，那么就会调用父类的无参构造器，即super()
  
 注意：
  父类的构造器不能被子类继承
  方法和属性可以被继承，权限不限制能否继承过来，限制的是能否直接访问
  先构造父类，后构造子类，先this后super
  
多态：
 多态分为两种：编译时多态和运行时多态。
  编译时类型：主观概念，把它看作什么。
  运行时类型：客观概念，实际它是什么。
    例：Animal a=new Dog();
         指着狗问，这个动物是什么？
         
      运行时多态的三原则：
  对象类型不变。
  只能对对象调用编译时类型中定义的方法。
  在程序的运行时，根据对象的运行时类型，找覆盖后的方法来调用。（运行时动态类型绑定）
  
      强制类型转换： 一定没有新对象生成。(父类的引用赋值给子类的引用需要进行强制类型转换)
      关键字：instanceof
           用法：引用  instanceof  类名    判断这个引用所指向的对象是否属于这个类。
    用在强制转换之前，避免类型转换异常。
   if(a instanceof Dog){
    Dog d=(Dog)a;
   }
   
 多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

修饰符static： 把对象相关的变成类相关的，它可以修饰属性、方法、代码块和内部类
 static修饰属性（类变量）：
  那么这个属性就可以用" 类名.属性名 "来访问，也就是使这个属性成为本类的类变量，为本类对象所共享。
  类加载的过程，类本身也是保存在文件中（字节码文件保存着类的信息）的，java会通过I/O流把类的文件读入JVM（java虚拟机），这个过程称为类的加载。JVM会通过类路径（CLASSPATH）来找字节码文件。需要的时候才会进行类加载，生成对象时是先加载后构造
  类变量，会在加载时自动初始化，初始化规则和实例变量相同。
  注意：
   类中的实例变量是在创建对象时被初始化的
   static修饰的属性，是在类加载时被创建并进行初始化，类加载的过程只进行一次，也就是类变量只会被创建一次。
   
 static修饰方法（静态方法）：
  会使这个方法成为整个类所公有的方法，可以用" 类名.方法名 "访问。
  static修饰的方法，不能直接访问本类中的非静态成员，但本类的非静态方法可以访问本类的静态成员。
  在静态方法中不能出现this关键字。
  父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。（在使用对象调用静态方法时其实是调用编译时类型的静态方法）
  java中的main方法必须写成static的原因：在类加载时无法创建对象，而静态方法可以不通过对象调用，所以在类加载时就可以通过main方法入口来运行程序。
  
 static修饰初始代码块：
  这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。
  可以用静态初始代码块初始化一个类。
  动态初始代码块，写在类体中的“{}”，这个代码块是在生成对象时运行，这种代码块叫动态初始代码块。
  
单例设计模式：
 一个类只允许有一个对象，保证所有引用的对象都是同一个对象。
 因为只允许存在一个对象，则不允许在外面直接new出新的对象，所以应该把构造器设为private，。
 在类内定义一个公开的静态方法，让使用者进行调用，通过该方法去获得一个实例。
 例：
  public calss Singleton{
   private static Singleton s;
   private Singleton(){}
   public static Singleton newInstance(){
    if ( s == null)
     s = new Singleton();
    return s;
   }
  } 
  
修饰符final：不允许改变，可以修饰变量、方法、类
 final修饰变量：
  被fianl修饰的变量就会变成常量，一旦赋值不能改变
  常量可以在初始化时直接赋值，也可以在构造方法里赋值，只能在这两种方法里二选一，不能不为常量赋值
  常量不会有默认初始值
  锁定栈，使栈中的数据不可以改变
  静态常量只能在初始化时直接赋值
  
 final修饰方法：
  被final修饰的方法将不能被其子类覆盖，保持方法的稳定不能被覆盖
 
 final修饰类：
  被final修饰的类将不能被继承
  final类中的方法也都是final的
 
 注意：
  final不能用来修饰构造方法
  
访问权限控制： 
 private：
  本类内部可以访问
  不能继承到子类
 default：
  本类内部可以访问，同包其他类也可以访问。
  同包可继承
 protected：
  本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问。
  能继承到子类
 public：
  任何地方都可以访问 
  能继承到子类

0