环境变量
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();
通过使用克隆的方式,同一个流换个地址,解决同一个对象多次系列化出问题
-------------------------------