corejava

Posted 2020-08-05

环境变量

　　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　　-2⁶³ ~ 2⁶³-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();

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

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