Java SE-Review

目录

写在前面

磨刀不误砍柴工，其实，学习最难的不是来自于新体系的挑战，而是如何耐下心来温习旧的知识。

基本运算

byte short int long float double

运算结果

  1. 操作数有浮点型则为浮点型
  2. 操作数有long型则为long型
  3. 否则都为int型
/***
 * _ooOoo_
 * o8888888o
 * 88" . "88
 * (| -_- |)
 *  O\ = /O
 * ___/`---'\____
 * .   ' \\| |// `.
 * / \\||| : |||// \
 * / _||||| -:- |||||- \
 * | | \\\ - /// | |
 * | \_| ''\---/'' | |
 * \ .-\__ `-` ___/-. /
 * ___`. .' /--.--\ `. . __
 * ."" '< `.___\_<|>_/___.' >'"".
 * | | : `- \`.;`\ _ /`;.`/ - ` : | |
 * \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 * `=---='
 *          .............................................
 *       
 */

#逻辑运算	与&&	或||	非!
#位运算	与&	或|	非~	异或^	左移<<	右移>>
#幂运算	Math.pow(2，3)
#字符串连接	""+a+b	a+b不运算，直接转化为字符串		a+b+""	a+b先运算再转化为字符串
#三元运算符	condition?res1:res2

包机制

用于区别类名的名称空间，一般为公司域名倒置 package在最顶部 import导入包的类

JavaDoc

/**
 * @author 
 * @version 
 * @since 
 * @param  	加在方法上
 * @return 	加在方法上
 * @throws	加在方法上
 */
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
生成注释文档

Java流程控制

Scanner对象

import java.util.Scanner
Scanner scanner = new Scanner(System.in);
scanner.next();	scanner.nextLine();	//获取输入的字符串
scanner.hasNext();	scanner.hasNextLine();	//判断是否还有输入
scanner.close();
//进阶
scanner.nextInt();scanner.nextFloat();

next()

  1. 一定要读取到有效字符后才可以结束输入
  2. 对输入有效字符之前遇到的空白，会自动将其丢弃
  3. 只有输入到有效字符后才将其后面输入的空白作为分隔符或结束符
  4. 不能得到带空格的字符串

nextLine()

  1. 以Enter为结束符，返回的是输入回车之前的所有字符
  2. 可以获得空白

switch()

  1. 变量类型可以为byte short int 或char JavaSE7 开始支持String
  2. case必须为字符串常量或字面量
  3. break

反编译--查看.class文件，switch(String) 事实上是通过String.hashcode()来判断的

for循环

int[] num = {1,2,3,4,5};
for (int i:num){
    System.out.println(i);
}

for (int i=1;i<10;i++){
    for (int j=1;j<=i;j++){
    System.out.print(j+"*"+i+"="+(i*j)+"\t");
    }
    System.out.println();
}
//九九乘法表    "*"应加双引号，不然会被识别为char

      *
     ***
    *****
   *******
  *********
for (int i = 0; i < 5; i++) {
    for(int j=5;j>=i;j--){
       System.out.print(" ");
    }
    for(int j=0;j<=i;j++){
       System.out.print("*");
    }
    for(int j=0;j<i;j++){
       System.out.print("*");
    }
       System.out.println();
}
//打印三角形

方法

方法命名规则-首字母小写，驼峰原则

  • 修饰符
  • 返回值类型
  • 方法名
  • 参数
    • 参数类型
    • 参数名
  • 方法体

//cmd javac执行带有package的.java文件要到package的src路径下 执行全路径的.java文件

可变参数，(type... name) 本质是数组 只能定义一个，且在参数列表最后

数组

//获取数组长度
int[] num = new int[12];
int len = num.length;

数组长度是固定的，数组本身是对象，存储在堆中

数组里面的元素是相同类型，不能是混合类型

Arrays类

java.util.Arrays

Arrays.sort(num);//升序
Arrays.fill(num,0);//填充
Arrays.fill(num,1,0,5);//填充部分

冒泡排序

public static  int[] sort(int[] array){
        boolean flag = false;//记录是否修改  优化排序
        for (int i = 0; i < array.length-1; i++) {
            for (int j=0;j<array.length-i-1;j++){
                if (array[j+1]<array[j]){
                        int temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                        flag = true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }

面向对象

面向过程

  • 步骤清晰，第一步，第二步
  • 适合处理简单的事情

面向对象

  • 分类的思维模式，分类解决问题
  • 适合处理复杂的问题，多人协作
  • 本质：以类的方式组织代码，以对象的形式封装数据

面向对象三大特性

  • 封装 隐藏对象的属性和实现细节，对外提供公共的访问方式，防止数据的随意访问和修改
  • 继承 通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类
  • 多态 引用多态 方法多态
    • 引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，程序运行期间才确定。

默认无参构造

一旦有了有参构造，无参必须显示定义

类的加载

  • 类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构

super.调用父类的属性和行为

继承

  • 父类private 修饰的无法被继承
  • 新建子类先默认调用父类无参构造第一个，否则显性调用父类有参构造
  • this()本类构造方法 super() 父类构造器
    • this() super() 不能同时调用构造方法

重写原则

  • 两同两小一大
  • 继承关系
  • 静态方法不属于实例
  • 非静态方法才算重写
    • 方法名相同，参数类型相同
    • 子类返回类型小于等于父类方法返回类型
    • 子类抛出异常小于等于父类方法抛出异常
    • 子类访问权限大于等于父类方法访问权限

向上转型 父类的引用指向子类

多态

  • 动态编译：类型：可扩展性
  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
  • 存在条件：继承 方法重写 父类引用指向子类
  • private static final 不能重写

instanceof

当前类是否是指定类或其子类

x instanceof y 非父子关系会编译报错

static关键字

public class Person{
    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public Person {
        System.out.println("构造方法");
    }
}
//执行顺序
//静态代码块
//匿名代码块
//构造方法
//static只执行一次

import static java.lang.Math.random

static 关键字实现静态导入包~

抽象类

  • abstract修饰
  • 抽象类可以有非抽象方法，抽象方法的类必须是抽象类
  • 抽象方法 只有方法名字，没有方法的实现
  • 抽象类的所有方法，继承了他的子类必须实现，除非子类也是抽象类
  • 不能new，只能靠子类去实现

接口

  • 普通类只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范 约束和实现分离：面向接口编程
  • interface关键字
  • 实现了接口的类，必须实现接口的所有方法
  • 定义的属性都是public static final
  • 约束
  • 定义一些方法，让不同的人实现
  • 可以实现多个接口

内部类

异常Exception

异常指程序运行过程中出现的不期而至的各种状况，如文件找不到，网络连接失败，非法参数等

异常发生在程序运行期间，影响了正常的程序执行流程

  • 检查性异常
  • 运行时异常
  • 错误ERROR

异常处理异常关键字

  • try
  • catch
  • finally
  • throw 主动抛出异常，一般在方法中使用
  • throws

捕获多个异常，顺序先子类再父类

包装类

java为8种基本类型分别提供了对应的包装类型

装箱就是自动将基本数据类型转换为包装器类型，拆箱就是自动将包装器类型转化为基本类型

集合

graph LR A[集合框架] --> B[Collection] A[集合框架] --> C[Map] A[集合框架] --> Collecitons工具类 A[集合框架] --> 泛型 B--> D[List] D-->E[ArrayList] E-->add E-->remove E-->contains E-->size D-->F[LinkedList] F-->getFirst F-->getLast F-->removeFirst F-->removeLast B--> G[Set] G-->H[HashSet] G-->I[TreeSet] B-->Iterator迭代器 C-->J[HashMap] C-->K[LinkedMap]

HashMap 初始大小默认是2的4次方 16

  • 为了实习存取高效，尽量减少碰撞，尽量做到数据分配均匀
  • hash%length = hash&（length-1）length保证为2的n次方，位运算比取模运算快

加载因子：0.75

  • 加载因子比较大的时候，节省空间资源，耗费时间资源
  • 加载因子比较小的时候，节省时间资源，耗费空间资源
  • 0.75是折中设计

Lambda表达式

(parameters) -> expression
或
(parameters) ->{ statements; }

匿名函数

避免内部类定义过多

  new Thread(()->{System.out.println();}).start()

线程同步

多个线程操作同一个资源
队列加锁
Synchronized

  • 同步方法
  • 同步代码块
  • 获取锁失败排队
  • 死锁
    • 互斥
    • 请求与保持
    • 不剥夺条件
    • 循环等待条件

Lock(优先级高)

  • ReentrantLock
    • lock
    • unlock
    • trylock

线程通信

  • 缓冲区：消息队列
  • 标志位：红绿灯
  • wait()
  • notifyAll()

线程池

  • 池化技术
  • 最大连接数
  • 线程池大小
  • 存活时间
  • 存储队列
posted @ 2020-09-23 11:27  yourText  阅读(159)  评论(0)  编辑  收藏  举报