Java基础笔记汇总

不全面，只是学习笔记的汇总，记了一些我觉得重点的。

细碎基础：

Java全面支持Unicode编码。

类、方法、变量名以$，字母(Unicode字符集)，下划线开头，后面的可以是数字，字母，下划线。

如果我们没有手动初始化成员变量，系统会自动初始化。初的规则如下：

数字：0,0.0   布尔：false  char:\u0000   引用类型：null 

程序以public static void main(String[] args){}函数作为程序入口。

final：

修饰变量：常量(命名规范：全部大写，多个单词之间通过下划线隔开)

修饰方法：不能被重写

修饰类： 不能被继承

二进制数可以用_分隔表示 int a = 0b0000_0000_0000_0000_0000_0000_0000_0011;

数值前有0默认是八进制

equals比较内容是否相等，==比较是否是同一个对象

for (int u : list) // forEach语法

    System.out.println(u);

package：

package必须位于非注释行第一句。

包名：域名到这写

import：

引入外部的类

Import  static :导入类的静态属性

内存模型说明图：

基本数据类型

boolean true和false

byte 一个字节，8bit,-128~127

char 两个字节，数值对应Unicode字符

short 两个字节

int 四个字节，整数默认类型,23亿，如果数据的大小没有超过byte/short/char的表述范围，则可以自动转型。

long 八个字节

float 1.000111f 不加字母默认是double

double 浮点数可以用 314e-2 科学计数法的写法

运算符

java 中有三种移位运算符

<< 左移运算符，num << 1, 相当于 num 乘以 2

>> 右移运算符，num >> 1, 相当于 num 除以 2

>>> 无符号右移，忽略符号位，空位都以 0 补齐

C语言系的三目运算符

(布尔表达式)?A:B

高级数据类型

字符串

String，StringBuilder，StringBuffer

检测字符串是否相等 检测两个字符串内容是否相等时使用“equals”；比较两

个字符串的引用是否相等时用“=="

得到字符串的长度 字符串变量名.length();

数组

int[] a= new int[3];

int[]  c= {23,43,56,78};   //长度：4，索引范围：[0,3]

int[][]  a = new int[3][];a[0] = new int[n];（任意大小）

容器

ArrayList:数组 查看多于修改

   add(元素) add(索引，元素) remove(元素) remove(索引) set(索引，元素) get(索引)

   for+get  foreach() Iterator ListIterator

LinkedList :链表，修改多于查看 ，多了些链头与链尾的方法

HashSet: 重写 hashcode +equals

add(元素)  remove(元素)

HashMap: 键不能重复 必须重写 hashcode +equals ，值可以重复

    put(k,v) remove(k) get(K) containsKey containsValue

    获取值:values()  keySet()+get entrySet()+getValue()

    获取键:keySet  entrySet() +getKey()

    获取键与值: keySet()+get  entrySet() +getKey() getValue()

Hashtable:键与值都不能为null 线程安全

迭代器Iterator

1)、java.util.Iterator + hasNext() next() remove()

2)、foreach :java.lang.Iterable +iterator()

比较器

1)、实体类可以排序  java.lang.Comparable +compareTo

2)、排序比较器(解耦、多种排序规则) java.util.Comparator +compare

  List+Collections.sort()

  TreeSet

  TreeMap

面向对象

封装

通过private、default 、protected、public关键字实现属性或方法的封装。

“高内聚，低耦合”

继承

extends 继承，扩展

Java中类只有单继承，没有像C++那样的多继承

方法重写(加@override注解)

=：方法名保持一致

>=: 子类权限修饰符可以大于等于父类的。

<=, <=: 子类的返回值类型小于等于父类的类型。 子类声明异常类型不能超过父类的类型。

Object类：

1. 是我们所有类的根基类

2. toString

3. equals、hashcode

4. wait、notify、notifyAll

基本数据类型拥有对应的包装类Wrapper type，包装以后即可作为对象使用

boolean Boolean tostring以后为“true”或“false”

char Character

byte Byte

short Short

int Integer Integer a = new Integer(1000);

（-128到127之内默认用int，不用Integer对象，例如Integer a=10；Integer b=10； a==b成立（实际只是int数据比较而不是对象比较））

long Long

float Float

double Double

void Void

构造方法是被隐式声明为 static 方法

构造方法函数：

1. 方法名必须跟类名保持一致

2. 无返回类型

3. 通过new来调用

4. 无参构造器问题：

a) 如果我们没有手动定义构造器，系统会自动为我们添加一个无参的构造器

b) 如果我们自己定义了构造器，系统就不会为我们添加无参构造器

5. 构造方法的第一句总是:super，即调用直接父类的构造方法。

a) 有继承关系的构造方法调用的顺序

super 指的是对直接父类的引用，super关键字必须是构造方法中的第一行语句。

可以通过super来访问父类中 被子类覆盖的方法或属性。

this：

普通方法中，调用本方法的对象，方法中默认隐式参数。

构造方法中，正要初始化的对象。

还可以用来，调用其他的构造方法，this(参数。。);

static：

用它修饰的变量和方法，就变成了静态变量和静态方法。从属于类。通过类名即可调用。实际存储于方法区中。

多态(polymorphism)，父类可以使用子类的方法

三个必要条件：继承、方法的重写、父类引用指向子类对象

方法的重载(Overload)：

两同(同一个类、同一个方法名)三不同(参数列表不同：类型、个数、顺序)

抽象类：

抽象类无法实例化，也就是说，不能 new 出来一个抽象类的对象（实例）

如果一个类中包含了抽象方法，那么这个类一定要声明成 abstract class，也

就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以

包含抽象方法，也可以包含具体方法。在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类

中所定义的所有抽象方法；否则，该子类需要声明成一个 abstract class。

接口interface：

类实现接口 implements 可以多个接口名（接口可以多继承）

常量和抽象方法

常量默认是public static final 不可变

方法默认似public 

可以多继承extends 多个接口

异常处理

Java 异常类类层次图：

Java 异常处理通过 5 个关键字 try、catch、throw、throws、finally 进行管理。

throw 用来抛出一个异常，在方法体内。语法格式为：throw 异常对象。

throws 用来声明方法可能会抛出什么异常，在方法名后，语法格式为：throws 异常类型 1，异常类型 2... 异常类型 n。

两种处理异常的方式

一、在方法中用 try...catch 语句捕获并处理异常，catach 语句可以有多个，用来匹配多个异常。例如：

public void p(int x){

　　try{...}

    catch(Exception e)

    {...}finally{...}}　　

二、对于处理不了的异常或者要转型的异常，在方法的声明处通过 throws 语句抛出异常。例如：

public void test1() throws MyException{

　　...

　　if(....){throw new MyException();}}

数据流IO

字节流，使用的数组是字符数组char [] chs

 输入流:InputStream read()+close()

       FileInputStream()

 输出流:OutputStream write()  +flush() +close()

       FileOutputStream

字符流，使用的数组是字节数组byte [] bt

 输入流:Reader read()  +close()

       FileReader()

 输出流:Writer  write() +flush() +close()

       FileWriter()

缓冲流

1)、字节缓冲流

BufferedInputStream

BufferedOutputStream

2)、字符缓冲流

BufferedReader   readLine()

BufferedWriter    newLine()

转换流:

编码与解码概念

 编码：字符   --编码字符集->二进制

 解码: 二进制 --解码字符集->字符

InputStreamReader(字节输入流,"解码集")

OutputStreamWriter(字符输出流,"编码集")

节点流

1、字节数组 字节 节点流

    输入流:ByteArrayInputStream read() + close()

    输出流:ByteArrayOutputStream write() +toByteArray()

其他处理流

1、基本类型+String  保留数据+类型

  输入流:DataInputStream    readXxx

  输出流:DataOutputStream  writeXxx

2、引用类型 (对象) 保留数据+类型

   反序列化 输入流:ObjectInputStream  readObject()

   序列化  输出流:ObjectOutputStream  writeObject()

注意:

1)、先序列化后反序列化；反序列化顺序必须与序列化一致

2)、不是所有的对象都可以序列化， java.io.Serializable

      不是所有的属性都需要序列化，transient

3、打印流 PrintStream  println() print()

4、三个常量 : System.in /out/err   System.setIn() setOut() setErr()

装饰中模式使用数据流

BufferedReader fr = new BufferedReader(

            new InputStreamReader(new FileInputStream(

                "E:\\Desktop\\test.c"), "gbk"));

线程Threads

实现Runnable +run()

启动:使用静态代理

  1、创建真实角色

  2、创建代理角色 Thread+引用

  3、代理角色.start()

同步:并发 多个线程访问同一份资源  确保资源安全  -->线程安全

synchronized -->同步

一、同步块synchronized(引用类型|this|类.class){}

二、同步方法synchronized

实用工具库：

正则表达式

String line = "sfdsfsdfdsfs";

Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");

Matcher m = p.matcher(line);

while(m.find()) {

    System.out.println(m.group());//group()可加参数1，2，3获取正则()获取值

}

时间相关类

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

long start = System.currentTimeMillis();

System.out.println(sdf.format(start));

File类

File常用方法:

1、文件名

getName() 文件名、路径名

getPath()路径名

getAbsoluteFile() 绝对路径所对应的File对象

getAbsolutePath() 绝对路径名

getParent() 父目录 ,相对路径的父目录，可能为null 如. 删除本身后的结果

2、判断信息

exists()

canWrite()

canRead()

isFile()

isDirectory()

isAbsolute()：消除平台差异，ie以盘符开头，其他以/开头

 3、长度 字节数  不能读取文件夹的长度

length()

4、创建、删除

createNewFile() 不存在创建新文件,存在返回false

delete() 删除文件

static createTempFile(前缀3个字节长，后缀默认.temp) 默认临时空间

staticcreateTempFile(前缀3个字节长，后缀默认.temp,目录)

deleteOnExit() 退出虚拟机删除,常用于删除临时文件

5、操作目录

mkdir() 创建目录，必须确保 父目录存在，如果不存在，创建失败

mkdirs() 创建目录，如果父目录链不存在一同创建

list() 文件|目录 名字符串形式

listFiles()

static listRoots() 根路径

JDBC

基础

Class.forName("com.mysql.jdbc.Driver");

conn = DriverManager.getConnection("jdbc:mysql://localhost/mydata?user=root&password=root");

stmt = conn.createStatement();

rs = stmt.executeQuery("select * from dept");

while (rs.next()) {

System.out.println(rs.getString("deptno"));

}

防止SQL注入

pstmt = conn.prepareStatement("insert into dept2 values (?, ?, ?)");

pstmt.setInt(1, deptno);

pstmt.setString(2, dname);

pstmt.setString(3, loc);

pstmt.executeUpdate();

批量执行

PreparedStatement ps = conn.prepareStatement("insert into dept2 values (?, ?, ?)");

ps.setInt(1, 61);

ps.setString(2, "haha");

ps.setString(3, "bj");

ps.addBatch();

ps.setInt(1, 62);

ps.setString(2, "haha");

ps.setString(3, "bj");

ps.addBatch();

ps.executeBatch();

回滚支持

conn.setAutoCommit(false);

stmt = conn.createStatement();

stmt.addBatch("insert into dept2 values (51, '500', 'haha')");

stmt.addBatch("insert into dept2 values (52, '500', 'haha')");

stmt.executeBatch();

conn.commit();

conn.setAutoCommit(true);

} catch(SQLException e) {

try {

if(conn != null)

{conn.rollback();

conn.setAutoCommit(true);

}

其他：

网络Net

类

1、InetAddress封装 IP 及DNS方法:

getHostAddress() 返回ip地址

getHostName() 返回域名|本机为计算机名

InetAddress.getLocalHost();

InetAddress.getByName("ip地址|域名");

InetSocketAddress:封装端口

1)、创建对象:

InetSocketAddress(String hostname, int port)

InetSocketAddress(InetAddress addr, int port)

2)、方法：

getAddress()

getHostName()

getPort() 

2、URL

URI(Uniform resource identifier)统一资源标识符,用来唯一的标识一个资源。

URL（Uniform Resource Locator）统一资源定位器,它是一种具体的URI

四部分组成: 协议  存放资源的主机域名  端口 资源文件名(/)

创建

URL(String spec)  :绝对路径构建

URL(URL context, String spec)  :相对路径构建

方法

System.out.println("协议:"+url.getProtocol());

System.out.println("域名:"+url.getHost());

System.out.println("端口:"+url.getPort());

System.out.println("资源:"+url.getFile());

System.out.println("相对路径:"+url.getPath());

System.out.println("锚点:"+url.getRef()); //锚点

System.out.println("参数:"+url.getQuery());//?参数 :存在锚点  返回null ,不存在，返回正确

3、TCP: ServerSocket  Socket

基于tcp: 面向连接 安全 可靠 效率低 ，类似于打电话

一、面向连接:  请求-相应 Request --Response

二、Socket编程

1、服务器: ServerSocket

2、客户端: Socket

4、UDP: DatagramSocket DatagramPacket

    UDP：以数据为中心   非面向连接  不安全 数据可能丢失  效率高

客户端：

   1)、创建客户端   DatagramSocket  类  +指定端口

   2)、准备数据  字节数组

   3)、打包  DatagramPacket +服务器地址 及端口

   4)、发送

   5)、释放资源

服务器端：

   1)、创建 服务端  DatagramSocket  类  +指定端口

   2)、准备接受容器 字节数组  封装 DatagramPacket

   3)、包 接受数据

   4)、分析

   5)、释放资源

泛型

<> 泛型类、泛型方法、泛型接口、泛型擦除、通配符 ? extends super 泛型嵌套

注解Annotation

可以用代码获取的解释说明

反射Reflect

Class<?> clazz = Class.forName(path);
Object obj = clazz.newInstance();//生成对象
Field field = c.getField("fieldName");//全部属性用getDeclaredField
field.setInt(targetObj, 99);//私有属性需要设置field.setAccessible(true);
Method method = obj.getdMethod("methodName", new Class[]{String.class,int.class});//全部方法用getDeclaredMethod
method.invoke(target,new Object[]{"str",123});
动态代理

/** * 1、写一个类实现InvocationHandler接口 * @author Administrator * */public class LogProxy implements InvocationHandler {private LogProxy(){}//2、创建一个代理对象private Object target;//3、创建一个方法来生成对象,这个方法的参数是要代理的对象,getInstacne所返回的对象就是代理对象public static Object getInstance(Object o) {//3.1、创建LogProxy对象LogProxy proxy = new LogProxy();//3.2、设置这个代理对象proxy.target = o;//3.3、通过Proxy的方法创建代理对象，第一个参数是要代理对象的classLoader//第二个参数是要代理对象实现的所有接口,第三个参数是实现类InvocationHandler的对象//此时的result就是一个代理对象，代理的是oObject result = Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), proxy);return result;}/** * 当有了代理对象之后，不管这个代理对象执行什么方法，都会调用以下的invoke方法 */@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {//if(method.getName().equals("add")||method.getName().equals("delete")) {//Logger.info("进行了相应的操作");//}Object obj = method.invoke(target, args);if(method.isAnnotationPresent(LogInfo.class)) {LogInfo li = method.getAnnotation(LogInfo.class);Logger.info(li.value());}return obj;}}