一些java学习笔记（转）

准备工作
1、JDK：java develop kit ，java开发工具包；
2、JRE：java runtime environment, java 运行时环境；
3、JDK 的三个版本：
J2SE：java标准版，桌面程序和小应用程序的开发
J2EE：java企业版，企业级的开发（WEB开发）
J2ME：主要是手持移动设备程序的开发；
4、JAVA的特性：
a 简单的
java屏弃了c++中一些复杂的操作，如指针、结构等
b 面向对象的
java是完全面向对象的
c 健壮的
java通过检查编译和运行时的错误来保证程序的可靠性
java提供的垃圾回收机制，保证了内存不会泄露
d 安全的
e 解释的
  java是解释执行的，而不是编译执行的，通过生成java的字节码，来解释执行
f 平台无关的
  java生成字节码，由java解释器来解释
g 多线程的
  在语言级上支持多线程
h 动态的
  java将变量或方法的引用转换成符号引用保存下来，传递给解释器，由解释器来动态决定其加载；
5、java跨平台的原理：
·java的跨平台是通过ＪＶＭ来实现的。Java的编译器在编译java的源代码的时，并不是将变量和方法的引用编译为数值引用，也不确定内存布局，而是将这些信息保存在字节码中，由解释器在运行时候确定内存布局。也就是说，java的编译器生成的字节码中，并不包含与特定硬件平台相关的信息。
·java解释器的执行过程分为：字节码的装载、校验、执行。在装载过程中，由装载器装载字节码，所有本地代码都被装载到同一个内存命名空间里，而所有外部引用的代码都有自己的内存命名空间，本地代码只是保存了对其引用的符号信息。当所有字节码都装载完成后，java解释器就确定了内存布局。
·通过实现不同平台下的ＪＶＭ，来实现字节码的跨平台；
６、jdk\bin\jar.exe 可以对程序进行打包、发布；
７、在java中，文件名必须与被声明为public的类相同，所以在java文件中，最多只能有一个public的类；
８、java解释器加载的是类，因此，对类名的大小写是敏感的；
９、／** …..*／这种注释可以自动生成一个注释的文档；
10、当定义了classpath后，java解释器就会按照classpath进行查找，而不查找当前目录，若想查找当前，则在classpath中加入。;
11、java提供了８种基本数据类型：
　　byte　有符号的１字节的整数　（-128---127）
注　byte类型参与运算时，java会将其类型自动提升为int，
如　byte a ; a= (byte)(a*2）；

    short   有符号的２字节的整数　　注　同上　
　   int (4) 
  long (8)　　　   注　默认１.3这样的数，默认为double

      float (4)
      double (8)                         
    char     无符号的２个字节　　unicode编码，表示
  boolean
12、java数组在定义时，不能直接分配空间；
Int[] array;
Array={1,3}; //这种写法是error的
13、java中二维数组，列数可以不相同，实际上每一行都是一个一维数组；
14、int i=3 ,count;
Count=(i++)+(i++)+(i++);
Out: count=12;
Count=(++i)+(++i)+(++i);
Out: count=15;


位运算



１、计算机数据常用１６进制表示；
２、原码：第一位为符号位，０表示正，１表示负；
反码：正数的反码是原码本身，负数的反码是符号位不变，其他各位按原码取反；
补码：正数的补码是原码本身，负数的补码是符号位不变，其他各位取反加１；
３、计算机采用补码进行数据处理；
４、位运算符：
&　按位与　　　　只有两位都为１时，结果为１；
｜　按位或　　　　两位任意一位为１时，结果为１；
^   按位异或　　　只有两位不同时，结果才为１；
～　按位取反　　　
５、移位运算符：
<<　左移
>>　带符号右移　　　（负数：所有空位都补１）
>>>　无符号右移
６、API

Java.lang.Integer. toHexString(int i); 　　//整型转换为其对应的十六进制数
７、移位运算的效率要高于存储运算，在一些讲求效率的程序中，应考虑使用移位运算；
８、<<１　左移一位，相当于乘以2；
>>１　右移一位，相当于除以2；






Java的面向对象编程



１、OOP：描述的是对象和对象之间的相互作用；
２、面向过程和面向对象编程的区别：
·面向过程编程，一般是先确定算法，然后考虑数据结构，而面向对象编程，则是先确定数据结构，在设计算法；
·面向过程编程，往往是将数据保存到数据结构中，并通过方法来操作数据，而面向对象的编程中，则是将数据和方法组织到一个对象中；
３、类是对象的摸板，对象是类的实例；
４、面向对象编程思路：先将现实世界实体抽象成对象，然后考虑解决的方法；
５、类的构造方法，没有返回类型，名字与类名相同，构造函数用于对类对象定义初始化状态，每个类必须有构造函数，若没显示定义，则java编译器会自动生成一个不含参数的构造方法，若显示定义，则java不会提供任何默认构造方法；
６、new　关键字：
·为对象分配空间　　·引起构造函数的调用　　·返回一个对象的引用
７、方法的重载（OverLoad）
·构成重载的条件：方法名称相同，参数个数或参数类型不同；
８、this　关键字：
·this关键字代表着一个特定的类对象本身；
·this　只在方法内部使用，代表调用方法的对象本身；
·this　可以简化构造方法的调用this();
９、java的成员方法在内存中都只包含一份拷贝，被所有对象所共享；而成员变量则有多份拷贝，属于不同对象所拥有。当特定对象调用一个成员方法的时候，this被表示为指代该对象，去调用成员方法，然后与该对象的成员变量进行关联；
10、static 关键字
·被定义为static的方法或变量，是属于一个类的，而不属于某一个对象的；
·static的方法或变量，在类加载的时候，就分配了内存空间，并且在内存中只有一份拷贝；
·在static的方法中，不可以引用非static的方法和变量，而在非static的方法中，可以引用static的方法或变量；
·static的方法和变量可以通过类和对象来引用（实质还是通过类来引用）
11、final 关键字
  ·被声明为final的常量，是不允许被修改的，并且在定义时，就必须对其进行初始化（实际也可以将初始化放到构造函数中）；
·常把final的常量，同时声明为static，可以节约空间；
12、java中通过extends 实现继承，不允许多继承；
13、override
在子类中实现一个与父类中，具有相同名称，返回类型，参数的方法，称为方法的重写；
14、super 关键字
·super 提供了子类中访问被重写或隐藏了的父类的方法或变量的方法；
·在子类的构造函数中，都会在第一句隐式地加入一句super（），如果父类中没有这样的构造函数，则会报错；
15、多态：
java中根据传递参数所引用的对象的不同，来调用相应子类的方法；
·编译时多态：方法的重载；
·运行时多态：根据传递对象的不同，来调用不同的方法；
16、instanceof
用于判断一个对象是否为一个类的实例；


包

1、使用package关键字定义包，包层次对应目录的层次；
2、使用 javac –d 目录 *.java 编译，生成包
  使用 java 包名.类名来执行文件；
3、使用import 来导入一个包；


类的修饰符

1、·public：公共类           
·default：包内可见
2、final：被声明为final的类，是最终类，不允许被继承；
  ·java.lang.String类是个final类；
3、abstract：包含抽象方法的类；
      不允许产生抽象类的对象；
      可以将不包含任何抽象方法的类，声明为abstract，以避免产生这个类的任何对象；
4、方法访问说明符
  public   公共的
protected 同一包中或不同包中的子类可以访问
default   同一包内可以访问
private   同一个类内可以访问
5、其他方法说明符
· static 
· final   
将方法定义为final，则在继承过程中，子类将不能重写该方法；
private和static方法，自然都是final的；
· abstract 不包含方法体的方法；
· native：JNI（Java Native Interface）
      ·JNI允许JVM中运行的java程序与其他语言编写的应用程序进行互操作；
      ·JNI可以理解为java程序和本地应用程序的之间的中介；
      ·JNI程序编写步骤：
1、写一段java代码；
        2、编译java代码
        3、创建 .h文件（使用javah –jni 类名）
        4、写一个本地方法的实现
        5、创建一个共享的库
        6、执行java程序；
垃圾回收

1、没有任何引用的对象，成为垃圾内存，会被垃圾回收器回收；
2、垃圾回收器是自动运行的，当JVM感觉到内存不够的时，就会自动运行来处理垃圾内存；
3、垃圾回收器在真正回收一个对象之前，会调用finalize（）方法，子类重写这个方法，来做一些配置系统资源或执行其他清除的工作；
4、API

Java.lang.Object. finalize(); //垃圾回收前调用该方法
Java.lang.System.gc() 　   //运行垃圾回收器


接口

1、接口中全部方法默认为public abstract，那么在实现接口的类中，也必须为public的；
2、实现一个接口，若想去创建一个实现类的对象，那么就必须去实现接口中的所有方法；
  否则，实现类必须声明为abstract；
3、接口中允许有数据成员，这些成员默认为 Public static final
4、java中允许一个接口继承另一个接口；
5、java 中不允许类的多继承，但允许接口的多继承；
6、先继承类，然后再实现接口；


内部类

1、在一个类中，定义一个类，这个类就叫做内部类；
2、当我们建立一个内部类时，内部类的对象就会与外部类的对象之间产生某种联系，这种联系是通过this 引用形成的，从而使的内部类可以随意访问外部类的成员（包括private的）
3、在内部类的方法中，通过this.x 引用内部类的成员变量；通过outer.this.x引用外部类的成员变量；
4、使用外部类名.内部类名（outer.inner）的方式，在outer类外部引用内部类；
5、在未产生一个外部类对象时，不能使用new来直接创建一个内部类对象，因为内部类对象都是和一个外部类对象想关联的，使用 Inner in=outer.new Inner()可以创建（outer为已创建的外部类对象）；
6、内部类可以放到方法、条件语句体、语句块中，但不管嵌套的层次有多深，内部类都可以随意访问外部类的成员；
7、当内部类在一个方法内部定义的时候，那么方法的参数或局部变量，必须声明为final，才可以被内部类调用；
8、内部类可以被声明为protected 和private的；
9、内部类可以被声明为static的类，这时，创建内部类对象就不需要必须首先产生一个外部类对象做为前提了，而这样，内部类也不能随意访问外部类的非static的成员了；
  （static切断了外部类与内部类之间的关系）
10、非static的内部类中，不能有静态的方法或变量存在；
11、内部类可以实现接口；
12、将内部类声明为private的，可以很好的隐藏实现的细节；
13、匿名内部类可以用于实现适配器类，在AWT编程中，经常使用到；


异常处理

1、Exception类：定义了程序中遇到的轻微错误条件，需要我们在程序中进行处理；
2、Error类：定义了程序中遇到的严重错误条件，内存溢出，文件格式错误等，不需要我们去处理，而由java 运行时系统来进行处理；
3、Java程序如果在运行的过程，发生了异常，就会自动生成一个异常对象，并将该异常对
  象提交给java运行时系统（抛出异常throws），接受到异常对象，java运行时系统就会查找能够处理该异常的代码，并将该异常对象交给它进行处理（捕获异常catch）。如果找不到能够处理该异常的代码，java程序就会终止运行；
4、try/catch/finally 来处理异常；
5、在try中，发生异常的语句后的程序段，不会被执行，而是直接跳转到catch语句里去；
执行完catch里的语句，会继续执行后面的语句；finally里的语句始终都要执行；
6、API
  Java.lang.Throwable. getMessage()
  Java.lang.Throwable. toString()
Java.lang.Throwable. printStackTrace()   //以上都是捕获异常的信息
6、在方法的参数列表后，跟上 throws Exception 用来声明，该方法有可能会抛出异常。一旦，产生了异常，则异常会被抛给该方法的调用者。如果方法的调用者不做处理，依旧可以逐级向上抛，直到main函数也不做处理，将该异常抛给 java runtime system来处理；
7、throw 实际抛出一个异常
throws 声明抛出一个异常
8、RunTime 异常一般不需要我们去处理，而由运行时系统自己处理；
9、子类在覆盖父类方法的时候，不能抛出新的异常，而只能是相同的异常或该异常的子集；


String类



1、String 类是final类，不允许被继承；
2、= = 是比较变量的值（引用对象的地址）是否相等
  equals（）是比较变量的内容（引用的对象内容）是否相等；
3、+ 用于连接字符串；
4、+ 和+=是java中唯一被重载的操作符；
5、String 变量是个常量，一旦被创建，就不能被改变；
6、在处理大量字符串的程序中，常用 StringBuffer 来代替String ；
7、API
  Java.lang.StringBuffer.append() //
8、StringBuffer 创建的对象空间初始为16个字符，但当空间不够的时候，会自动增加；
9、java中的传递参数，都是以传值的方式，基本类型是传递值的拷贝，引用类型是传递的引用的拷贝；
10、当打印一个对象的时候，会调用该对象的toString方法；


克隆机制：
·为了获得对象的一份拷贝，我们可以使用Object类中的clone（）方法，在派生类中重写clone（）方法，并声名为public；
·必须在继承类中实现cloneable接口（标识接口），来告诉编译器：该对象可以克隆了；
·在继承类的clone（）中调用 super。Clone（）；
·浅拷贝：当在类中没有引用对象存在时，类中所有的变量都可以拷贝过去；
深拷贝：当类中有存在引用对象时，将该引用对象一同克隆一份的克隆方法；（将引用对象所对应的类也重写clone方法，并且实现cloneable接口，并且在引用类的clone方法中，将clone方法返回值赋值给引用的变量中）；
数组操作：

1、API
java.lang.system.arraycopy //数组的拷贝
  java.util.Arrays.sort     // 对数组进行排序
  java.util.Arrays.binarySearch // 对有序数组进行搜索
2、排序对象数组，数组中的所有对象都必须实现Comparable接口；


封装类：



1、针对八种基本类型，java中存在八个封装类；
2、数字字符串转换为Integer类型： valueOf(String s);
  数字字符串转换为int 类型：   parseInt(String s);


反射API

1、java.lang.reflect包


单例模式：

1、每一个类都只有一个实例；
2、单例模式的构造方法是private的
3、主要用于：需要一个类只提供一个实例的时候，例如计数器；
4、单例类的一个实现：
  class Singleton
{
  private static Singleton st=new Singleton();
  private Singleton()
  {
}
public static Singleton getInstance()
{
return st;
}
}
5、参考书《java与模式》阎宏电子工业出版社





多线程：

1、程序：程序是一系列计算机指令的集合，以文件的形式存储在计算机磁盘上；
  进程：进程是一个程序在其自身地址空间内的一次执行活动，它可以申请系统资源，被调度、运行；
  线称：线程是一个进程中的一个单一连续控制流程，一个进程可以拥有多个线程，没有独立的内存空间，而是与其他线称共享同一进程的地址空间；
2、进程与进程切换上下文切换耗时，远远低于线程间切换的效率；
3、java在语言级支持多线程；
4、实现多线程的方法：
  一、继承Thread 类；
  二、实现Runnable接口；
5、实现run（）方法，并用start（）启动一个线程；
6、setDaemon（boolean ）设置一个线程为后台线程，当程序的线程都为后抬线程时，程序就会退出；
7、yield()方法可以使一个线程放弃自己的时间片，而让出执行机会给其他线程；
8、setPriority设置一个线程的优先级；
9、java的线程调度机制，不支持时间片轮换，而是支持抢占式的方式，对于具有相同级别的线程，如果操作系统支持时间片轮换，则java虚拟机也支持这种方式；
10、sleep()：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。该线程不丢失任何监视器的所属权。
11、线程同步：同步块和同步方法；
  ·synchronized（obj）块，一个线程进入synchronized块前，先给obj对象监视器加锁，其他线程则不能进入，等离开时，则对监视器解锁；
  ·synchronized方法，使用synchronized声明一个方法，这种方法的锁是加到this对象上边；
12、线程的死锁：
13、wait()：导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
notify()：唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个wait方法，在对象的监视器上等待。
14、终止线程：
·设置一个flag变量；
·Intrrupte() 中断有一个线程；


集合类：

1、集合框架（Collections Framework）：就是一个用来表示和操作集合的统一的架构，包含了实现集合的类和接口；
2、集合框架中的接口：
  CollectionàSetàsortedSet           MapàsortedMap
        à List
·collection：集合层次中的根接口，JDK中没有提供这个接口的直接实现类；
·set：不能包含重复的元素。Sortedset是元素按照升序排列的set；
·list：是一个有序的集合（不是指的排列顺序），可以包含重复的元素，提供按索引访问的方法；
·map：包含了key-value对。不能包含重复的元素。Sortedmap是一个将key值按升序排列的map；
3、ArrayList
·arraylist可以看成是一个可以增长容量的数组；
·arraylist的实现是使用了一个对象数组，当容量不够的时候，会重新分配一个数组，将原来数组中的元素拷贝到新数组中；
·数组à List (Arrays.asList())
Listà数组   (arrayList.toArray())
·迭代器（Itertator）：
·对于没有提供get方法的集合类，可以使用iterator来返回集合中的元素；
·可以提供一个通用的方法来返回元素，如
Pubilc static vid printElems(Collection c)
{
    Iterator i=c.iterator();
    While(i.hasNext())
    {
      System.out.println(i.next());
}
}
4、collections
·collections类中所有的方法都是static的
·自然排序
·使用比较器排序
5、LinkedList
  ·使用双向循环链表实现的；
  ·可以实现栈、队列、双向队列；
·ArrayList和LinkedList的比较：

  ·arrayList的低层是采用数组来实现的，而linkedlist是采用双向链表实现的，linkedlist的每一个对象中，都包含了除了自身数据元素外的，两个值，一个指向前一个元素，一个指向后一个元素；
  ·如果经常要在list中的第一个位置插入数据或频繁插入或删除操作，则使用LinkedList
  如果要经常地查找某一个元素，则使用ArrayList,它提供了按索引查找；
6、HashSet
  ·实现set接口的hash table，依靠hash map来实现的；
  ·hashset的默认负载因子是0.75
  ·每一个对象都有个hashCode，根据内存地址计算出来的；
·hashset中存储元素，则元素的类必须实现hashCode（）和equals（）
7、ThreeSet
·ThreeSet是依靠threeMap来实现的；
·ThreeSet中的元素是有序的，缺省按照升序排列，因此threeset中的元素必须实现Comparable接口；
·HashSet 和TreeSet的比较：

HashSet是基于hash算法来实现的，通常其性能都是优于TreeSet，通常都是使用hashset的；只有使用到排序功能的时候，才会使用TreeSet；
8、HashMap
9、TreeMap
·按照key排序
·HashMap和TreeMap的比较：

  与set的一样；




I/O操作

1、一个java中的File类，即可以表示一个文件，也可以表示一个目录；
2、在程序运行过程中，产生的运行时临时程序，可以通过deleteOnEixt(),在程序结束的时候清除这些中间文件；
3、java中的读取和写入都是通过流来完成的；
4、流：字节的源或目的；
5、流分类：节点流和过滤流(需要一个存在的节点流对象)；
6、InputStream：
  Abstract int read()
  Int read(byte[])
  Int read(byte[],int off,int length)
  Void close()
7、outputStream:
  Abstract void write(int b)
  Void write(byte[] b)
  Void write(byte[] b,int off, int length)
  Void flush()
  Void close()
8、基本流：
  ·FileInputStream 和 FileOutputStream   (节点流)
·BufferedInputStream 和 BufferedOutputStream (过滤流)
9、当使用bufferedoutputstream（）的时候，只有当缓冲区满的时候，才会输出，可以使用flush（）或关闭close（）方法强制输出；
10、DataInputStream 和DataOutputStream (过滤流)
    提供对基本数据类型的读写操作；
11、PipedInputStream 和 PipedOutputStream （管道流）
    用于线程之间的通信；
12、java的输入\输出,提供的是一种链结机制，可以把两个流首尾相结，形成一个流管道。这种模式被称为装饰模型（Decorater）。
13、Reader 和 Writer 是用来读写字符流；
  InputStream 和 OutputStream 是用来读写字节流；