首页 > 代码库 > corejava

corejava

环境变量

  JAVA_HOME : jdk安装目录

  PATH : ;%JAVA_HOME%\bin  

  CLASSPATH : .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;  //指示编译器和JVM,到哪去找所需要的类

package xx;

import java.util.*;

注释

  1)//  单行注释

  2)/*  */  多行注释

  3)/**  */  多行注释,配合JavaDoc工具使用

命名规范

  包名:全小写

  类名:单词首字母大写

  变量名/函数名:首单词小写,后面的单词首字母大写

  常量名:全大写

数据类型

对象类型

简单类型

  bute  1B  -128~127

  short  2B  -32768~32767

  int   4B  -2147483648~2147383647

  long  8B  -263 ~ 263-1

  float  4B

  double  8B

  char  2B

  boolean  true / false

&  |  //非短路  依然进行后面的判断 例:a>b & c<d  一定进行c<d的判断

&&  ||  //短路  满足条件不进行后面的判断

流程控制

  1)if(){

     }

     else{

     }

  2)switch(i){      //整型表达式 byte short int char

      case 1:xx;break;

      case 2:xx;break;

      default:xx;

     }

  3)while(){

     }

  4)for(;;){

    }

函数

  声明:public static 返回值类型 函数名(参数表)

  实现:{}  必须和声明一致(主要指返回值类型)

  调用函数:函数名(实际参数);

数组

  int[] a;   int a[];

对象

  属性:有什么

  方法:能做什么

  各司其职  对象应该保持简单性

  弱耦合性  对象和对象之间的联系应该尽量弱化

  可重用性  

  可扩展性

类  class

  对象共性的抽象;对对象的认识;类是对象的模板

  属性:实例变量

  1)有默认值  数值类型:0  布尔类型:false  对象类型:null

  2)作用范围:至少是全类内部

  3)命名冲突时,局部优先

  方法:

  方法的声明:对象能做什么

    修饰符 返回值类型 方法名(参数表) 抛出的异常

  方法的实现:对象怎么做

重载

  1)参数个数不同

  2)参数类型不同

  3)参数类型排列不同

构造方法

  1)没有返回值类型

  2)方法名必须和类名相同

  3)不允许手工调用,构造过程中自动调用一次

封装

  public  公开

  private  私有  只能在本类内部访问

  属性私有 提供公开的setxxx/getxxx用来访问属性

  方法私有 只给自己调用

继承

  父类:子类的共性抽象出来

  所有子类能够访问的父类属性和方法,即是子类从父类中继承到的属性和方法

  private  私有  不能继承

  (default)  本类+同包  同包子类可以继承

  protected  受保护的  本类+同包+不同包的子类  可以继承

  public  公开  可以继承

  构造方法不能继承

  方法的覆盖

    返回值类型 方法名 参数表相同,访问修饰符相同或更宽

多态

  子类对象可以看做是父类的对象

  子类对象可以放入父类引用

  1)对象类型不变

  2)只能对引用调用起引用类型中声明的方法

  3)运行时,根据对象实际类型找子类覆盖之后的方法

  子类引用赋值给父类引用 可以直接赋值

  父类引用赋值给子类引用 必须强制类型转换 保证编译通过

  运行时可能发生类型转换异常

  在强制类型转换之前,可以用instanceof判断,避免类型转换异常  //引用 instanceof 类名

  作用

    将不同子类对象统一看作父类对象,屏蔽不同子类的差异

  多态的常见用法

  1)多态用在方法参数上,形参可以是父类引用,实参可以传子类对象  //m(A a): 可以用A的任何子类对象作为参数

  2)多态用在方法的返回值上  // A m():m方法完全可以返回A的某个子类对象

 abstract 抽象的  extends继承接口

  类  抽象类只能声明引用,不能创建对象

  方法  抽象方法 只有声明 没有实现

  如果一个类中有抽象方法,这个类就必须是抽象类

  子类继承抽象类,如果子类不希望也成为抽象类,就必须实现父类中声明的所有抽象方法

  利用abstract,可以把方法声明抽象到父类中,而方法实现留在子类 更好的体现“共性放在父类”原则 

修饰符组合:

  private static final 均不能喝abstract联用

interface 接口  implements实现接口

new 接口(){};

  1)所有的属性都是公开静态常量

  2)所有方法都是公开抽象方法

  3)没有构造方法

  接口之间可以多继承  interface IA extends IB,IC{} 

  一个类在继承另外一个类的同时,还可以实现多个接口  class Impl extends ClassE implements IA,ID{}

  利用接口实现多继承,不会破坏类之间树状关系的简单性

  解耦合的工具 标准

  把标准的使用者和标准的实现者分离

接口的回调

  在定义接口之后,先有接口的使用者,后有接口的实现者 使用者通过接口调用实现者中的方法

内部类

  1)内部类可以访问外部类的私有成员,而不破坏封装

  2)接口公开,接口的实现类作为内部类隐藏起来,强制弱耦合

匿名内部类

  new 接口(){

  };  //实现了接口的没有名字的内部类对象

==============================

Object 类   Java中所有类的父类

  1 Object o;  o中可以装任何对象

  2 Object类中的方法 是所有对象都具有的方法

1)finalize():由垃圾收集器在回收垃圾对象时,最后调用

2)getClass():返回对象的实际类型

3)toString():返回对象的String形式 打印一个对象就是打印这个对象的toString方法的返回值

4)boolean equals(Object o):判断this和o内容是否相同

===============================

集合框架

集合:容器 一个对象,用来储存其他多个对象

Collection    //父接口

特点:元素是Object

List    //子接口

  特点:元素有顺序 可以重复

  实现类:

    1)ArrayList 用数组实现  轻量级  线程不安全  查询快  增删慢

    2)Vector 用数组实现  重量级  线程安全

    3)LinkedList 用链表实现  查询慢  增删快

Set    //子接口

  特点:元素无顺序 不可以重复

  遍历:迭代遍历

    Iterator it = set.iterator();

    while(it.hasNext()){

      Object o = it.next();

      System.out.println(o);

    }

  实现类:

  HashSet

  把自定义对象放入HashSet,为保证元素不重复 必须:

  1)覆盖hashCode() 保证相同对象返回相同int

  2)覆盖equals() 保证相同对象返回true

Map

  特点:元素有键值对组成 其中键唯一 值可以重复

  方法:

  put(Object k,Object v):把k-v这个键值对放入Map

  get(Object k):返回Map中对应的v

  实现类

  1)HashMap:1.2  允许用null作为key或者value

  2)Hashtable:1.0  不允许null作为key或者value

===================================

泛型  模板编程

不同泛型之间不能相互赋值

泛型的通配符:

? :任何类型

? extends Number:Number类或Number的任何子类

? super Number:Number类或Number的任何父类

? extends Comparable:任何实现Comparable接口的类

  泛型方法:

  <T extends Number&Comparable>:T既是Number的子类,又实现Comparable接口

  泛型类:

  泛型技术应用在集合框架中:实现类型安全的集合

  泛型:预定集合中的元素类型  

==================================

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();

==================================

异常处理 容错性

异常的分类

Throwable  //所有异常类总的父类

  Error  错误  //子类

  Exception  异常  //子类

  1)已检查异常

    不可避免  必须处理  

  2)RuntimeException  未检查异常

    可以避免  可处理可不处理

throw:动作,抛出一个异常 将异常对象作为方法的返回值返回 等同于return语句

异常的处理:

  1)throws  声明抛出

  2)try-catch 捕获异常

  try-catch-finally

  try{  }

  catch(IOException e){  }

  finally{  }

方法的覆盖:

  访问修饰符相同或更宽 方法名,参数表,返回值类型 相同

  子类不能比父类抛出更多的异常

=====================================

多线程

进程:OS中并发的一个任务

CPU分时间片  宏观并行  微观串行

线程:在一个进程中,并发的一个顺序执行流程

线程的组成:

  1)CPU

  2)Data  堆空间共享 栈空间独立

  堆空间:存储对象(存储实例变量)

  栈空间:存储局部变量

  3)Code  由程序员指定

  继承Thread类或者实现Runnable接口

  一个Thread对象代表一个线程

线程的同步:

  当多线程并发访问临界资源(同一个对象)时,如果破坏了原子操作(不可分割的操作),就会造成数据不一致

  synchronized(o){}:对o加锁的同步代码块

  任何对象都有一个互斥锁标记,用来分配给线程

  只有难道对象锁标记的线程,才能进入对该对象加锁的同步代码块

  线程退出同步代码块,会释放相应的锁标记

同步方法:

  在整个方法的范围内,对当前对象加锁

  只有拿到对象锁标记的线程,才能调用该对象的同步方法

 线程间通信:等待-通知

任何对象都有一个等待队列,用来存放线程

t1:o.wait()必须放在对o加锁的同步代码块中.t1会释放其拥有的所有锁标记;同时t1会阻塞在o的等待队列中

t2:o.notify()/notifyAll()必须放在对o加锁的同步代码块中,从o的等待队列中释放一个/全部线程

====================================

java.io.File  File对象代表磁盘上的一个文件或者目录

createNewFile():创建新文件

mkdir():创建新目录

delete():删除

exists():文件对象所代表的文件(或目录)是否存在

=================== 

I/O流

按照数据方向:输入流/输出流

按照数据单位:字节流/字符流

按照流的功能:节点流/过滤流

字节流:以字节为单位,可以出来一切数据

字符流:以字符为单位,只能处理文本数据

节点流:实际传输数据的流

过滤流:给节点流增强功能

InputStream/OutputStream 字节流的父类

FileInputStream/FileOutputStream 文件字节流 节点流

  write(int a):把字节a写出去

  write(byte [] bs):把字节数组bs全部写出去

  write(byte [] bs,int off,int len):把bs的一段写出去

  int read():从文件中读一个字节 返回-1为结束

  int read(byte[] bs):从文件中读多个字节,读满bs 返回值为实际读到的字节数 以-1为结束

  int read(byte[] bs,int off,int len):从文件中读多个字节,放入bs的一段。返回值为实际读到字节数,以-1为结束

1.创建节点流  FileOutputStream fos = new FileOutputStream("1.dat")

2.封装过滤流  BufferOutputStream out = new BufferOutputStream("fos")

3.读/写数据   out.write("A")

4.关闭流    out.close()    

out.flush()  //清除缓冲区

DataInputStream/DataOutputStream 直接读写8种基本类型和String

BufferedInputStream/BufferedOutputStream 缓冲

PrintStream:写8种基本类型 缓冲 

---------------------------------------

编码解码

String str = "字符串用例";

byte[] bs1 = str.getBytes("GBK");

String str2 = String(bs1,"Big5");

System.out.println(str2);

--------------------------------------

字符流

Reader/Writer 字符流父类

FileReader/FileWriter  文件字符流 节点流

BufferedReader/BufferedWriter  缓冲流 过滤流  BufferedWriter 现在被PrintWriter代替

InputStreamReader/OutputStreamWriter  桥转换,字节流转换字符流

  OutputStream fos = new FileOutputStream("poem.txt");

  Writer ow = new OutputStreamWriter(fos);

  PrintWriter out = new PrintWriter(ow);  也可以 PrintWriter out = new PrintWriter(fos);

  还可以直接 PrintWriter out = new PrintWriter("poem.txt");//JDK5.0以后

--------------------------------------

对象序列化:将对象通过流传输  

ObjectOutStream/ObjectInputStream

类对象实现Serializable接口才能放在流上传输

FileInputStream fis = new FileInputStream("student.dat");

ObjectInputStream in = new ObjectInputStream(fis);

Student o1 = (Student)in.readObject();

Student o2 = (Student)in.readObject();

in.close()

System.out.println(o1);

System.out.println(o2);

 

关键字:transient   //只能修饰属性,修饰的属性叫临时属性,不会参与序列化,

-------------------------------

实现Cloneable接口,可以克隆对象

覆盖克隆方法
public Object clone(){  //修饰符原protected覆盖成public

  try{

    return super.clone()

  }catch(CloneNotSupportedException e){

  e.printStackTrace();

  return null;

  }

}

s.setAge(19);  

Object o = s.clone(); 或者 Student s2 = (Student)s.clone();

out.writeObject(o); 或者out.writeObject(s2);

out.close();

通过使用克隆的方式,同一个流换个地址,解决同一个对象多次系列化出问题

-------------------------------

 

 

 

 

 

corejava