classpath

java中classpath配置的是class文件生成的地址，和运行java命令去找class文件的地址,一般不做配置

java数据类型

基本类型：byte(1字节),short(2字节),int(4字节),long(8字节),float(4字节),double(8字节),char(2字节),boolean
引用类型：class,接口,数组,枚举等

基本类型转换

boolean不能转换为其他数据类型
默认转换
byte,short,char->int->long->float->double
byte,short,chart之间不转换,他们参与运算首先转换为int
在定义long或者float类型变量时，加L或者F(整数默认是int，浮点数默认是double)

byte a = 3;
byte b = 4;
// a+b结果为int
//byte c = a + b;
byte c = (byte) (a+b);

float f = 3.14F;
long l = 10000000L;

方法重载

在同一个类中，允许存在一个以上的同名方法，只要参数的个数或者参数类型不通即可。与返回值类型无关，只看方法名和参数列表

数组

数组初始化：数组必须初始化，然后才能使用，为数组的元素分配内存空间，并为每个数组元素赋值

数组初始化方式

静态初始化：初始化只指定数组长度，由系统为数组分配初始值 int[] a = new int[3]
动态初始化：初始化时指定每个数组元素的初始值，由系统决定长度 int[] a = new int[]{1,2,3}
数组常见错误
不要同时进行静态和动态赋值
数组越界
空指针异常

方法

可变参数

//定义
typeName... parameterName

public class VarargsDemo {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
 
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

java内存分配

栈存放的是局部变量
堆存放的是所有new出来的对象
方法区 (方法在栈里执行)
本地方法(系统相关)
寄存器(cpu)：不可控制

堆内存特点

每一个new出来的对象都有一个地址值
每个变量都有默认值
- byte,short,int,long都为0
- float,double 为0.0
- char 为’\u0000’
- boolean 为false
- 引用类型为null
使用完毕就变成垃圾，但并没有立即回收，会在垃圾回收器空闲时回收，这就是java占内存的原因

int[] a = new int[3];

栈内存特点

用完就释放
栈内存的两个引用指向同一个堆内存空间，无论操作哪个，都针对同一个地方

public class ArgDemo{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        change(a,b);
        
        int[] arr = new int[]{1,2,3,4,5};
        change(arr);
    }
    
    public static void change(int a,int b){
        a = b;
        b = a + b;
    }
    
    public static void main(int[] arr){
        for(int x = 0 ; x < arr.length;x++){
            if(x%2==0){
                arr[x] = arr[x] * 2;
            }
        }
    }
}

java对象内存图

成员变量和局部变量

成员变量在类中
局部变量在方法中定义或方法参数
成员变量在堆内存中
局部变量在栈内存中
成员变量随着对象的创建而创建，随着对象的消失而消失
局部变量随着方法的调用而存在，随着方法调用完毕而消失
有默认初始化值
没有默认初始化值，必须定义赋值后使用

访问修饰符

private

权限修饰符
可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问

static

可以修饰成员变量和成员方法
随着类的加载而加载
优先于对象存在
被类的所有对象共享
可以通过类名调用
静态方法中没有this关键字
静态方法只能访问静态成员变量和静态方法

静态变量和成员变量

静态变量属于类，所以也称类变量
成员变量属于对象，所以称为实例变量(对象变量)
静态变量存储于方法的静态区
成员变量存储于堆内存
成员变量随着对象的创建而创建，随着对象的消失而消失
静态变量随着类的加载而加载，随着类的消失而消失
静态变量可以通过对象调用，也可以通过类名调用
成员变量只能通过对象名调用

继承

低耦合：类与类之间的关系
高内聚：独立完成一件事情的能力
单继承
子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法

在子类方法的局部范围找，有就使用
在子类的成员范围找，有就使用
在父类的成员范围找，有就使用
如果找不到，报错

多态

某一个事物，在不同时刻表现出不同状态
多态
- 继承
- 重写
- 父类引用指向子类引用

成员变量编译看左边，运行看左边
构造方法创建子类对象时，访问父类构造方法，对父类的数据进行初始化
成员方法编译看左边，运行看右边
静态方法编译看左边，运行看左边
向上转型 Fu f = new Zi();
向下转型 Zi z = (Zi) f;

正则表达式

字符
- a 字符a
- \ 反斜杠
- \n 换行
- \r 回车
字符类
- [abc] a,b或c
- [^abc] 任何字符除了a,b,c
- [a-zA-Z] a-z或A-Z
- [0-9] 0到9
预定义字符类
- . 任意字符
- \d 数字:[0-9]
- \w [a-zA-Z_0-9] 单词字符
边界匹配器
- ^ 行的开始
- $ 行的结尾
- \b 单词边界不是单词字符的地方
数量词
- x? x,一次或一次也没有
- x* x,零次或多次
- x+ x,一次或多次
- x{n} x,恰好n次
- x{n,} x,至少n次
- x{n,m} x,至少n次但不超过m次
  Pattern和Matcher
  要先find() 然后group(捕获),不然报错IllgalstaeException

获取任意范围随机数

(int) (Math.random() * (end - start + 1)) + start

System

静态类

成员方法

public static void gc() 垃圾回收器调用finalize(); 不要频繁调用
public static void exit(int status) 终止当前运行的java虚拟机，非0表示异常终止
public static long currentTimeMillis()
public static arrarycopy()

常见数据结构

栈先进后出压栈弹栈
队列先进先出
数组
链表数据和地址
树
哈希表

List的子类特点

ArrayList 底层数据结构是数组，查询快，增删慢，线程不安全，效率高
Vector 底层数据结构是数组，查询快，增删慢，线程安全，效率低
LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高

泛型

泛型类 public class 类名<泛型类型1…> 泛型类型必须是引用类型
泛型方法
泛型通配符
- 泛型通配符<?> 任意类型
- ? extends E 向下限定，E及其子类
- ? super E 向上限定，E及其父类

静态导入

import static 包名….类名.方法名
方法必须是静态的
如果有多个同名的静态方法，必须加前缀

IO

异常

程序异常: Throwable
严重问题: Error
问题: Exception (编译问题，运行问题(RuntimeException))

一旦try里面出现了问题，就会抛出异常，然后和catch里的异常进行匹配，一旦匹配到了，就执行catch语句，然后结束了try…catch继续执行后面的语句

throws

使用定义方法时，需要把出现的问题暴露出来，让调用者去处理，那么通过throws在方法上标识，
方法抛出的是编译时异常必须要处理，如果抛出的是运行时异常可以不用处理

throw

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转，用异常把对象抛出

finally

finally语句块一定会被执行，catch里有return语句会先执行finally语句块，然后执行return语句，用于释放资源

自定义异常

继承Exception
继承RuntimeException

流

流向

输入流(读)，输出流(写)

数据类型

字节流,字符流(操作文本)

InputStream 字节输入流
OutputStream 字节输出流
Reader 字符输入流
Writer 字符输出流

序列化流

ObjectOutputStream 序列化将对象按照流一样的方式存入文本文件或者网络中传输

ObjectInputStream 反序列化将文本文件中的流对象或者网络中的流对象数据还原成对象

//序列化
ObjectOutputStream obs = new ObjectInputStream(new FileOutputStream("d:\\a.txt"));
Person p = new Person();
obs.writeObject(p);
obs.close();


//反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\a.txt"));
Object o = ois.readObject();
ois.close();

要实现序列化的对象须实现Serialible接口，
如果不想某个属性被序列化加上transient
public static final long serialVersionUID = “-283289349237498723”; //随机生成

Properties

json
load
store

多线程

如果程序只有一条执行路径是单线程，
如果有多条执行路径则是多线程

什么是进程

通过任务管理器，可以看到进程的存在；
只有运行的程序才有进程；
就是正在运行的程序，是系统进资源分配和调用的独立单位
每一个进程都有他自己的内存空间和系统资源

什么是线程

在同一个进程内可以执行多个任务，每个任务可以看成一个线程
线程是程序的执行单元

单线程：如果程序只有一条执行路径是单线程
多线程：如果有多条执行路径则是多线程

Java运行原理

java命令启动java虚拟机，启动jvm，等于启动了一个应用程序，该进程会自动启动一个“主线程“，然后“主线程“去调用某个类的main方法，所以main方法运行在主线程中

实现多线程

extends Thread

class Mythread extends Thread{
    @Override
    public void run(){
        // some code
    }
}
public class Test{
    public static void main(String[] args){
        //
        Mythread m1 = new Mythread();
        Mythread m2 = new Mythread();
        
        m1.start();
        m2.start();
        
        //不能同一个线程对象调用两次start
    }
}

实现Runnable

线程调度

分时调度所有线程轮流使用CP的使用权，平均分配给每个线程占用CPU的时间片
抢占式调度优先让优先级高的线程使用CPU

线程默认优先级是5，优先级值为0-10

线程控制

线程休眠 sleep(long millis)
线程加入 join() 为了某些线程执行完毕
线程礼让 yield()
后台线程 setDaemon(boolean on)
中断线程 stop() interrupt()

线程生命周期

新建创建线程对象
就绪有执行资格，没有执行权
运行有执行资格，有执行权
- 阻塞由于一些操作，让线程处于该状态没有执行资格，没有执行权，而另一些操作可以激活，激活后处于就绪状态
死亡线程对象变成垃圾，等待被回收

线程安全问题

多线程
有共享数据
多条语句操作共享数据

解决线程完全问题实现

同步代码块 synchronized 或者Lock

synchronized(对象){
    需要同步的代码块
}

同步的特点

多个线程
多个线程使用同一个锁对象

死锁

两个或两个以上的的线程在执行过程中因争夺资源产生的一种互相等待的情况
同步嵌套容易产生死锁问题

等待唤醒

wait() 释放锁，notify() 在wait()处唤醒
notify()

线程转换图

线程组

线程池

设计模式

面向对象设计原则

单一职责高内聚，低耦合
开闭原则对扩展开放，对修改关闭
里氏替换原则在任何父类出现过的地方都可以用子类代替
依赖注入原则依赖于抽象，不要依赖于具体实现
接口分离原则
迪米特原则一个对象对其他对象尽可能的少了解

设计模式分类

创建型模式
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
- 建造者模式
- 原型模式
- 单例模式
结构型模式
- 外观模式
- 适配模式
- 代理模式
- 装饰模式
- 桥接模式
- 组合模式
- 享元模式

行为型模式

模板方法模式
观察者模式
状态模式
职责链模式
命令模式
访问者模式
策略模式
备忘录模式
迭代器模式

解释器模式

单例模式

//饿汉
public class Student{
    private Student(){}
    
    private static Student s = new Student();
    
    public static Student(){
        return s;
    }
}

//懒汉,会产生线程安全问题，所以同步代码块
publiic class Teacher{
    private Teacher(){}
    private Teacher t = null;
    
    public synchronized static Teacher getTeacher(){
        if(t == null){
            t = new Teacher();   
        }
        return t;
    }
}

GUI

网络编程

网络三要素

IP地址
端口
协议
IP地址分类
A类 1.0.0.1~127.255.255.254 第一号段为网络号段 + 后三段的主机号段一个网络号： 256256256
B类 128.0.0.1~191.255.255.255 前二号段为网络号段 + 后二段的主机号段一个网络号： 256*256
C类 192.0.0.1~223.255.255。254 前三号段为网络号段 + 后一段的主机号段一个网络号： 256
D类 224.0.0.1~39.55.255.254
E类 240.0.0.1~247.255.255.254

特殊的IP地址

127.0.0.1 回环地址
x.x.x.255 广播地址
x.x.x.0 网络地址

端口

正在运行程序的标识
有效端口: 0~65535 其中0-1024系统进程端口

协议

UDP 将数据源和目的封装成数据包，不需要建立连接，每个数据包的大小限制在64k；因无连接，不可靠协议，不需要建立连接，速度快
TCP 建立连接，形成传输数据的通道；在连接中进行大量数据传输，通过3次握手完成连接，是可靠协议；必须建立连接，效率低

Socket

Socket套接字：网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的符套接字

类加载器和反射

类的加载

当程序要使用某个类时如果该类还未加载到内存中，则系统会通过加载，连续，初始化三步来实现对这个类的初始化

加载
- 就是将class文件读入内存中，并为之创建一个Class对象
- 任何类被使用时系统都会创建一个class对象
连续
- 验证是否有正确的内部结构，并和其他类协调一致
- 准备负责为类的静态成员分配内存，并设置默认初始化值
- 解析将类的二进制数据中的符号引用替换为直接引用
初始化

类加载器的组成

BootStrap ClassLoader 跟类加载器负责java核心类的加载比如System,String等 jre/rt.jar
Extension ClassLoader 扩展类加载器负责JRE的扩展目录中的jar包加载 JRE目录下lib目录下的ext目录
System ClassLoader 系统类加载器负责JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路劲

反射

java反射是在运行状态对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态的获取的信息以及调用对象的方法的功能称为反射机制。

class类：

成员变量 Field
构造方法 Constructor
成员方法 Method

java