Java Basic

1. Java是面向对象的，所有的java程序都是以一个class的开始的，

所以，Java有成员变量和局部变量。（没有全局变量），成员变量也是class中的一个变量，变量一般声明为private，然后有一个方法public暴露出来访问这个变量。

2. 基础数据转换:

1)容量小的自动转容量大的数据类型:byte,short,char->int->long->float->double

2容量大的可以强制转换成容量小的

3)boolean不能转换

4)byte,short,char 转换为int后运行

3.格式

1)大括号对齐

2)遇到｛缩进

3)程序块之间加空行

4)并排语句之间加空格

5)运算符两侧加空格

6)｛前面加空格

4. Java区分大小写，一个class中只有一个public的方法

5. switch( ) {

         case XX:

        ……

         case XX:

                   …..

         default:

                   …..

  }

1)小心case穿透，推荐使用break语句；

2)多个case可以合并到一起；

3)default可以省略，但不建议

4)java中的switch语句中只能探测int类型值

 ########################################################################################################################

面向对象的编程

类之间的关系：

1)关联关系：

2)继承关系： XX是一种XXX

3)聚合关系： 整体和部分（聚集，组合－密不可分）

4)实现关系： 接口

 

1.Java中的成员变量 可以初始化，不初始化就用默认值。

但Java的局部变量，必须初始化。

2.引用:Java 语言中除了基本类型之外的变量类型都称为引用类型.

对象是new出来的，放在堆内存中，运行时才能new出来。同一个类的每个对象有不同的成员变量存储空间。

3.构造方法:与类名相同，没有返回值（也没void）。New+构造方法，创建一个新对象。如果类中没有构造函数，系统就自动添加一个空构造函数。

4.类名首字母大写，变量名和方法首字母小写，驼峰标识。

5. 方法的重载overload：一个类中可以定义多个名字相同的方法，但参数不同,构造函数可以重载。

6.This关键字：在类的方法定义中使用的this关键字代表使用该方法的对象的引用。

    可以看作是一个变量，它的值是当前对象的引用。

7.当不知道当前变量是哪一个的时候，原则是：变量就近声明。

8.Static关键字:

   1)在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份。主要用处是计数

   2)可以通过对象应用或类名访问静态成员。即通过 类. 静态成员变量 ＝ 值，可以直接给static变量赋值。

   3)用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。静态方法不是针对某个对象调用的，所以不能不可访问非static的成员

9.内存中： 栈空间放局部变量；堆空间放new的对象；data seg放 static静态成员变量和字符串的值

10.如果想将一个类放入包中，在这个源文件的第一句话写package。Java编译器把包对应于文件系统的目录管理

11.import可以引入相应的类, import com.test.cat;  或引入package下所有类: import com.test.*; 访问位于同一个包中的类不需要引入

12.J2SDK中主要的包：java.lang不用引用,直接使用

    1) Java.lang-包含一些java语言的核心类，如String、Math、Integer、System和Thread

    2) Java.awt –包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些被用来构建和管理应用程序的图形用户界面(GUI).

    3) Java.applet-包含applet运行所需的一些类。

    4) Java.net-包含执行与网络相关的操作的类

    5) Java.io-包含能提供多种输入/输出功能的类.

    6) Java.util-包含一些实用工具类,如定义系统特性,使用与日期日历相关的函数.

13.Java权限修饰符置于类的成员定义前,用来限定其他对象对该对象成员的访问权限

修饰符

类内部

同一个包

子类

任何地方

private

Yes

　

　

　

default

Yes

Yes

　

　

protected

Yes

Yes

Yes

　

public

Yes

Yes

Yes

Yes

   对于class的权限修饰只可以用public和default:

  1)public类可以在任意地方被访问.

  2)default类可以被同一个包内部的类访问.

14.类的继承与权限控制: java中通过extends实现继承,子类自动拥有了父类的所有成员(成员变量和方法)

15.方法的重写:子类中可以根据需要对基类中继承来的方法进行重写. 重写方法的权限不能比基类中的方法更严格的权限控制.

16.Super关键字: java中使用super来引用基类的成分,在子类中使用.

17.继承中的构造方法:

    1)子类的构造过程总必须调用其基类的构造方法.

    2)子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法.

     >使用this(argument_list)调用本类的另外的构造方法.

     >如果调用super,必须写在子类构造方法的第一行.

    3)如果子类的构造方法中没有显示的调用基类的构造方法,则系统默认调用基类无参的构造方法.

18.JDK_API文档查询: http://docs.oracle.com/javase/7/docs/api/

19.Object类是所有java类的根基类,object类中有public String toString()方法,在进行String与其它类型数据的连接操作时(“info”+person),将自动调用该对象类的toString()方法.

20.Hashcode解释: 表中有唯一的hashcode,通过hashcode可以唯一的找到这个对象.

21.对象转型(casting)—提高了可扩展性,用基类的引用指定子类的对象.

   1) 一个基类的引用类型变量可以指向其子类的对象

   2) 一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)

   3) 可以使用引用变量instanceof类名来判断该引用类型变量所”指向”的对象是否属于该类或该类的子类.

   4) 子类的对象可以当作基类的对象来使用称作向上转型,反之称为向下转型.

22.动态绑定和多态: 指在执行期间判断所引用对象的实际类型(实际new的那个对象),根据其设计的类型调用其相应的方法.

多态存在的3个必要条件: (1)要有继承 (2) 要有重写 (3)父类引用指向子类对象

23.抽象类: 用abstract关键字修饰一个类时,该类称抽象类;用abstract修饰一个方法时,该方法叫做抽象方法.

   (1)含有抽象方法的类被声明为抽象类,抽象类必须被继承,抽象方法必须被重写

   (2)抽象类不能被实例化

   (3)抽象方法只需声明,而不需实现.

   public abstract class Person {

        private String name;

        private int age;

        public abstract void enjoy();

   }

24.final关键字: final 的变量的值不能被改写; final的方法不能被重写; final的类不能被继承

25.接口: 通过接口只能看到对象这一点.

     从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和抽象方法的定义,而没有变量和方法的实现.

    public interface Singer {

String country = "CN";

public void sing();

    }

    public interface Painter {

        public void draw();

   }

26.接口的特性:

   (1)接口可以多重实现;

   (2)接口中声明的属性默认为public static final的,也只能是publicstatic final(写不写都是)

   (3)接口中只能抽象方法,而且这些方法默认为public,也只能为public;

   (4)接口可以继承其它的接口,并添加新的属性和抽象方法.

   (5)多个无关的类可以实现同一个接口

   (6)一个类可以现实多个无关的接口

   (7)与继承关系类似,接口与实现类之间存在多态性.

    public class Profession implements Singer, Painter {

        @Override

        public void draw() {

            // TODO Auto-generatedmethod stub

        }

        @Override

        public void sing() {

            // TODO Auto-generatedmethod stub

        }

    }

 ########################################################################################################################

异常处理

1.Java异常概念: 运行期出现的错误. 观察错误的名字和行号最重要.

2.Java程序的执行过程中如出现异常事件,可以生成一个异常类对象,该异常对象封装了异常事件的信息并将被提交给java运行时系统,这个过程称为抛出(throws)异常.

3.当java运行时系统接收到异常对象时,会寻找能处理这一异常的代码并把当前异常对象交给其处理,这一过程称为捕获(catch)异常.

4.异常处理流程: 异常抛出->查找代码中有没有catch相应的异常->没有就让运行系统捕获这个异常,然后打印相应的信息到控制台.

5. Error: 称为错误,有java虚拟机生成并抛出,包括动态链接失败等,程序对其不做处理

    Exception: 所有异常的父类,其子类对应了各种各样可能出现的异常事件,一般要用户显示的声明或捕获

    RuntimeException: 一类特殊的异常,由系统自动检测并将它们交给省略的异常处理程序(用户可不必对其处理)

    

6. try {…}语句指定了一段代码,该段代码就是一次捕获并处理例外的范围.

在执行过程中,该断代码可能产生并抛出一种或几种类型的异常对象,它后面的catch语句要分别对这些异常做相应的处理.

如果没有例外产生,所有的catch代码段都被忽略不执行.

7. catch语句: 在catch语句块中是对异常进行处理的代码,每个try语句块可以伴随一个或多个catch语句,用于处理可能产生的不同类型的异常对象.

    在catch中声明的异常对象(catch(SomeException e))封装了异常事件发生的信息,在擦提出语句块中可以使用这个对象的一些方法获取这些信息.

   例如 printStackTrace()方法,用来跟踪异常事件发生时执行堆栈的内容

8. finally语句为异常处理提供一个统一的出口,无论try是否抛出例外,finally所指定的代码都要运行.

9. 在一个try语句块中,基类异常的捕获语句不可以写在子类异常捕获语句的上面. (先逮小的,在逮大的)

    try {

            语句;

        } catch (子类异常 ae) {

            System.out.println("Systemis under maintenance");

            ae.printStackTrace();

        } catch (基类异常 ae) {

            System.out.println("Systemis under maintenance too");

    }

10.自定义异常:

   1)通过继承Java.lang.Exception类声明自己的异常类.

   2)在方法适当的位置 生成自定义异常的实例,并用throw语句抛出

   3)在方法的声明部分用throws语句声明该方法可能抛出的异常.

11.异常和重写的关系: 重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常.

 ########################################################################################################################

数组

1.数组:多个相同类型数据组合,对这些数据的统一管理. 例如:int a1[] 或 int [] a1

2.数组变量属引用类型,数组也可以看成对象,数组中的每个元素相当于该对象的成员变量.即数组放在堆内存中.

3.Java中使用new创建数组对象,格式为: 数组名 = new 数组元素的类型 [ 数组元素的个数]

4.元素为引用数据类型的数组中的每一个元素都需要实例化.

5.动态初始化: 数组定义与为数组元素分配空间和赋值的操作分开进行. 例如: int[] a; a = new int[3]; a[0]=1, a[2]=2;a[3]=3;

6.静态初始化: 在定义数组的同时就为数组元素分配空间并赋值. 例如: int a[]= {1,2,3};

7.数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初始化

8.每个数组都有一个属性length指明它的长度.例如:a.length

 ######################################################################################################################## 

常用类

1.String:代表不可变的字符序列.

2.StringBuffer:Java.lang.StringBuffer代表可变的字符序列.

3.基本数据类型包装类:

 1).包装类(如Integer等)这些类封装了一个相应的基本数据类型数值,并提供一系列操作.

 2).以java.lang.Integer类为例

4.Math类:java.lang.Math提供了一系列静态方法用于科学计算,其方法的参数和返回值类型一般为double.例如abs绝对值,等

5.File类:Java .io.File 类代表系统文件名(路径和文件名)

6.枚举类型:Java .lang.Enum

  1)只能取特定值中的一个

  2)使用enum关键字

     public enum Mycolor {red,green,blue};  

    Mycolor m = Mycolor.red;

 ######################################################################################################################## 

容器: Java API所提供的一系列类的实例,用于存放对象.(1张图1个类3个知识点<For,Generic, Ato-boxing/unboxing>6个接口)

1. J2SDK所提供的容器API位于Java .util包内.

   

2. 容器类对象在调用remove、contains方法的时候需要比较对象是否相等,这会涉及到对象类型的equals方法和hashCode方法;对于自定义的类型,需要重写equals和hashCode方法以实现自定义对象相等规则. 注意:相等对象(equals)应该具有相等的hashCode. (重写equal方法的时候,必须重写hashCode方法.) 两个对象equals,两个对象必须拥有相同的hashcode.

3. Iterator接口: 像一个游标,开始的时候,游标处于容器中第一个对象的左边.

1)所有实现collection接口的容器类都有一个iterator方法,用以返回一个实现了Iterator接口的对象.

  2)Iterator对象称作迭代器,用以方便的实现对容器内元素的遍历操作.

  3)Iterator接口定义了如下方法:

boolean hasNext() //判断游标右边是否有元素.

object next()     //返回游标右边的元素并将游标移动到下一个位置.

void remove()    //删除游标左面的元素,在执行完next之后,该操作只能执行一次.

  4)Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法.(不能使用容器的remove方法,因为Interator在操作中会锁定容器中的对象.)

4. JDK1.5增强的for循环: 除了简单遍历并读出其中的内容外,不建议使用增强的for

  1)增强的for循环对于遍历array或Colloection的时候相当简单

    int[] arr={1,2,3,4,5};

    for(int p : arr) {

        System.out.println(i);

    }

5. Set 接口

  1)Set接口是Collection的子接口,Set接口没有提供额外的方法,但实现Set接口的容器类中的元素是没有顺序的,而且不可重复.

  2)Set容器相当于数学中”集合”概念.

  3)J2SDK API中 提供的Set容器类有HashSet,TreeSet等.

6. List接口

  1) List接口是Collection的子接口,实现List接口的容器类中的元素是有顺序的,而且可以重复

  2)List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素.

  3)J2SDK所提供的List容器类有ArrayList, LinkedList等.

7. 类java.util.Collections 提供了一些静态方法实现了基于List容器的一些常用算法.

   voidsort(List)        //对List容器内的元素排序

   voidshuffle(List)      //对List容器内的对象进行随机排序

   void reverse(List)     //对List容器内的对象进行逆序排序

   void fill(List, object)   //用一个特定的对象重写整个list容器

   void copy (List dest, List src) //将srcList容器内容拷贝到dest List容器

   int bindarySearch(List , object) //对于顺序的List容器,采用折半查找的方法查找特定的对象.

8. Comparable接口

  1)所有可以排序的类都实现了java.lang.Comparable接口,Comparable接口中只有一个方法 public int compareTo(object obj):

该方法:  返回0  表示:this==obj   

                返回正数表示:this> obj

              返回负数表示:this<obj

  2)实现了comparable接口的类通过实现comparaTo方法从而确定该类对象的排序方式.

9. Map接口

  1)实现Map接口的类用来储存”键-值”对.(key-value)

  2)Map接口的实现有HashMap和TreeMap等

  3)Map类中储存的”键-值”对通过键来标识,所以键值不能重复(是equals的意思,但比较hashcode快,所有重写equals必须重写hashcode).

Objectput(Object key, Object value)

Objectget(Object key)

Objectremove(Object key) 

booleancontainsValue(Object value)

booleancontainsKey(Object key)

voidputAll(Map t)

voidclear()

10. Auto-boxing/unboxing: 在合适的时候自动打包和解包.

1)打包--自动将基础类型转换为对象

2)解包--自动将对象转化为基础类型

   举例  Map m1= new HashMap ( );

             m1.put(“one”, 1)   //这里的1会自动打包成Integer(1);m1.put(“one”, new Integer(1));

11.泛型Generic

1)在定义集合的时候同时定义集合中对象的类型

例如:List<String> c = new ArrayList<String>();  //定义了List中的对象只能是String类型

########################################################################################################################

ClassLoader的类加载机制
1)并非一次性加载
2)需要的时候加载（运行期间动态加载）
   Java –verbose:class可以观察类的具体加载过程
3)Static语句块在加载后执行一次
4)Dynamic语句块每次new新的对象都会执行
   等同于构造方法中语句

JDK内置的ClassLoader
1)bootstrap class loader
    >>>Implemented by native language
    >>>load the core classes of jdk
2)extension class loader
    >>>load the class from jre/lib/ext
3)application class loader
    >>>load user-define classes
    >>>classloader.getSystemClassLoader()
4)other class loaders
    >>>Secure ClassLoader
    >>>URL ClassLoader

JDK 中Class Loader的层次关系

反射机制 : 通过java反射的API接口,去探索运行期间的一个class的内部结构,并且根据它的内部结构来决定它的方法如何调用

1. JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2.JAVA反射机制主要提供了以下功能：
    1).在运行时判断任意一个对象所属的类
    2).在运行时构造任意一个类的对象
    3).在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
    4).在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）

3.Java 反射相关的API简介：位于java.lang.reflect包中
    1)Class类：代表一个类
    2)Filed类：代表类的成员变量
    3)Method类：代表类的方法
    4)Constructor类：代表类的构造方法
    5)Array类：提供了动态创建数组，以及访问数组的元素的静态方法。该类中的所有方法都是静态方法

package com.infy.tests;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;public class TestReflect {public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException  {// TODO Auto-generated method stubString str = "com.infy.tests.T";Class<?> c = Class.forName(str);Object o = c.newInstance();Method[] methods = c.getMethods();for(Method m:methods){if(m.getName().equals("getS")){m.invoke(o);}}}}

获得类对象的三种方式：（类对象不用new的方法得到的）
1)也可以用类名.Class,获得这个类的类对象。
2)用一类的对象调用a.getClass()，得到这个对象的类型的类对象。
3)也可以使用Class.forName(类名)（Class类中的静态方法），也可以得到这个类的类对象，（注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。强制类加载，这种方法是经常使用的。