javaSE

摘要：本篇blog主要记录java基础，包括java运行机制，开发环境，语法、包机制、javadoc、流程控制、java方法、异常等

java运行机制

编程语言：

  • 解释型：运行的时候将程序翻译成机器语言 python
  • 编译型：有一个单独的编译过程，先把整个程序翻译成机器语言，执行时更快：c、c++

java是两种的混合体

java编译后形成一个字节码，字节码（class）介于源代码和机器码之间，经过解释器解释给操作系统得以执行

java开发环境

IDE：集成开发环境

java语法

0、注释

1、单行注释 //

2、多行注释 /* */

3、文档注释 /** */

4、有趣的代码注释

1
2
3
4
5
6
7
8
9
10
11
12
/**
*
*  佛曰:
*          写字楼里写字间，写字间里程序员；
*          程序人员写程序，又拿程序换酒钱。
*          酒醒只在网上坐，酒醉还来网下眠；
*          酒醉酒醒日复日，网上网下年复年。
*          但愿老死电脑间，不愿鞠躬老板前；
*          奔驰宝马贵者趣，公交自行程序员。
*          别人笑我忒疯癫，我笑自己命太贱；
*          不见满街漂亮妹，哪个归得程序员？
*/

1、标识符

类名、变量名、方法名都叫做标识符

  • 所有的标识符都应该以字母、美元符、下划线开始
  • 首字符之后可以是字母、美元符、下划线、数字的组合
  • 不能用关键字作为标识符：关键字是java的保留字
  • 标识符是大小写敏感的
  • 标识符甚至可以用中文^_^

2、数据类型

强类型语言：java、c++等：要求变量的使用严格符合规定
安全性↑ 速度↓
（如果一个变量一开始声明了某个类型，那么他之后就一直是这个类型）

弱类型语言：js、vb等

java数据类型分为基本类型和引用类型；

一、基本类型：

1、数值类型

  • 整数类型：
    byte：-128-128 1个字节
    short：-32768-32767 2个字节
    int：-21亿-21亿 4个字节
    long：8个字节

  • 浮点类型：float 4个字节 double 8个字节

  • 字符类型：char 2个字节

2、boolean类型：
占1位，true、false

二、引用类型

类、接口、数组

字节

bit 位：计算机内部数据最小的单位

byte 字节：计算机处理数据的基本单位，习惯上用B表示

1B = 8b

T、G、M、B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//关于进制
public class Base{
    public static void main(String[] args) {
        int i1 = 10;// 10
        int i2 = 010;// 8
        int i3 = 0x10;// 16
        //
        float f =0.1f;
        double d = 1.0/10;

        System.out.println(f==d);
        //f和d不相等
        
        float d1 = 212121212f;
        float d2 = d1+1;
        System.out.println(d1 == d2);
        //f和d相等
        //避免使用浮点数比较        
        //银行业务用BigDecimal
        
    }
}

关于char

1、汉字也可以，例如 ‘中’

2、所有的字符本质还是数字： 系统通常采用unicode编码，unicode表中字符和数字是一一对应的

例如 ‘a’ = 97 A=’65’

系统中的表示形式是 ‘\uXXXX’ 16进制，例如 a是’\u0061’

3、转义字符：
\t 制表符 \n 换行，这些在字符串里面会被转义

补充

1、对象和常量性质不同

1
2
3
4
5
6
7
8
9
10
11
class test {
    public static void main(String[] args) {
        String s1 = new String("hello world");
        String s2 = new String("hello world");
        // s1!=s2
        String s3 = "hello world";
        String s4 = "hello world";
        // s3=s4
        
    }
}

2、类型转换： 先转换类型，后进行运算

强制类型转换：（类型）变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class test{
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;
        //高→低: 强制类型转换
        //内存溢出
        
        //低→高: 自动类型转换 
        double c = i;
        // 1 不能对布尔值转换
        // 2 不能把对象类型转为不相干的类型 字符串转int
        // 3 转换时可能会出现内存溢出或者精度问题
        
        // 低 byte short char → int → long → float → double 高
        // 数字之间可以用下划线分割：
        int money = 10_000_000_000;
        int time = 10;
        long total = money*total;//会溢出
        long totall = (long)money*total;//不会溢出
           
        
    }

}

3、java 变量

1、含义：

变量：可变量

变量实质是内存中的一块特定空间，这个空间里面可以有不同的值

2、java变量：

java是强类型语言、每个变量都必须声明类型

3、格式

1
type varName = value
  • 变量类型：基本类型（8）、引用类型（例String）
  • 变量名须合法
  • 变量声明以分号结尾

4、作用域

类变量（static）、实例变量、变量

4、java 常量

1、含义：

初始化后不能改变

常量可以理解为一种特殊的变量

2、格式

1
final double PI = 3.14;
  • 常量名一般使用大写

3、java命名原则

原则：

  • 见名知意

  • 驼峰原则

    类：大写开头

    方法、变量：小写开头

  • 常量：大写+下划线 ： MAX_VALUE

5、运算符

算数运算符 + - * / % ++ –

赋值运算法 =

关系运算符 > < >= <= == != instanceof

逻辑运算符 && , ||, !

短路运算：a&&b，如果a为假，不需要进行运算，直接返回假

位运算符 & | ^ ~ >> << >>>

条件运算符 ?:

赋值运算符 += -=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
A = 0011 1100
B = 0000 1101

A&B = 0000 1100(对每一位进行和运算)
A|B = 0011 1101(对每一位进行或运算)
A^B = 0011 0001(相异为1，相同为0)
~B = 1111 0010(取反)

关于移位运算 >> << 
2*8 = 16	2*2*2*2
0000 0000 0
0000 0001 1
0000 0010 2

0000 0100 4
0000 1000 8
0001 0000 16
会发现，对于2而言：左移一位相当于乘2，右移一位相当于除2
即：
<<  =  *2
>>  =  /2 

2<<3 相当于*2*2*2

0000 0011 3
0000 1100 12 对于其他的数，则要具体运算，注意是将所有的数都移位


*/

关于+：如果有一个操作数是字符串，则结果为字符串

1
2
int score = 50;
String result = score<60 ? "不及格":"及格";

关于优先级：尽量用（）来处理，而不是让别人琢磨你的优先级

java包机制

java包就是文件夹！

1、命名机制

通常采用公司域名倒置作为包名

例如

package

2、包的导入

外层.内层.xxx

*：全部导入

JavaDoc

类、方法都可以注释

@author

@version 版本号

@since 最早的版本

@param 参数名

@return

@throws 异常抛出情况

Java流程控制

0、Scanner类

通过Scanner类获取用户输入

1
Scanner s = new Scanner(System.in);

next（）

  • 一定会读取到有效字符
  • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  • 只有输入有效字符之后才将其后面输入的空白作为分隔符或结束符
  • next（）不能得到带有空格的字符串

nextLine（）

  • 以enter作为结束符，可以获得回车之前所有的字符，包括空白

  • 可以获得空白

1、流程控制

  • 顺序结构：

    Java语句结构：从上到下，逐步执行

    他是任何一种算法都离不开的结构

  • 选择结构：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    if
    if-else
    if-else if-else if-else
    if(if)
        
    switch(expression){
        case value :
            
            break;//可选
        case value :
            
            break;//可选
        default://可选
    // expression : 
            //数值型变量，字符串
            //case标签必须为字符串常量或字面量
    // case穿透
    }

  • 循环结构

    1
    2
    3
    while(){
        
    }

    注意终止条件

    少部分情况需要循环一直执行，比如服务器的请求响应监听等

    循环条件一直为true就会造成死循环

    1
    2
    3
    do{
        
    }while();
    1
    2
    3
    4
    5
    6
    7
    8
    for(init;boolean;renew){
        
    }
    for(;i<10;i++);
    for(i;i<10;i++);//错，可以不写，不能只写个i
    //迭代：每一次运算的结果会作为下一次运算的初始
    //例如：每次i++后的结果都是下一次i++的起始
    for(int i=0;i<10;i++){};

    for循环是支持迭代的一种通用结构，是最有效、最灵活的循环结构

    迭代：可以理解为是循环的一种，循环分为静态循环和动态循环，静态循环每次都在执行一样的操作，动态循环则会改变数值，如果这次修改的数值会作为下次运算的基础，那就是迭代。

增强for循环：

增强for循环主要用来处理数组&集合对象，含义：把数组中的每一项遍历出来，赋给局部变量

1
2
3
for(声明语句:表达式){
    //
}

声明语句：声明局部变量，注意类型与数组元素的类型相匹配**(不能用以前的)**

表达式：表达式是要访问的数组名，或者返回值为数组的方法

break&continue

break：强制跳出循环体，不执行循环体中剩余语句（break语句也在switch语句中使用）

continue：跳过某次循环，不执行那次循环剩余的语句，但不跳出循环体

1
2
3
4
5
6
7
8
9
10
//一个关于continue的例子
int i=0;
while(i<100){
    i++;
    if(i%10==0){
        System.out.println();
        continue;
    }
    System.out.print();
}

Java方法(函数)

1、方法定义

what is method？

System.out.println()

System：类 out 对象 println 方法

java方法是语句的集合，一起执行一个功能

  • 方法包含于类or对象中

设计方法的时候，最好保持方法的原子性，即一个方法只完成一个功能，利于后期扩展
$$
\large(修饰符\quad修饰符…)\quad 返回值\quad方法名\quad(形参1、形参2…)
$$

修饰符：是可选的，限制了方法的调用范围

返回值类型：+void

方法名：小写开头，驼峰命名

参数类型：是一个占位符，可选

  • 形参：用来定义方法时所用的参数
  • 实参：实际调用方法时传递给方法的参数

方法体：定义方法的功能：注意返回值

2、方法调用

调用方式——非静态方法1：对象名.方法名（没有staic修饰，必须初始化对象）

调用方式2——静态方法：如果是类方法的话，可以直接在类中直接调用（static）

（非）静态方法之间可以相互调用。静态方法可以调用非静态方法，而不能反之。

static：

static修饰的方法与类同生命周期，没有static修饰的方法当创建对象时才产生

3、引用传递&值传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 如果传递的是八大基本类型，则无法改变值
public static void main(String[] args){
    int a=0;
    change(a);
   	System.out.println(a);
}
public static void change(int a){
    a=-1;
}
// 如果传递的是对象(数组、实例)，则可以改变值（数组元素的值，实例属性的值）
public static void main(String[] args){
    int[] a=new int[1];
    change(a);
   	System.out.println(a[0]);
}
public static void change(int[] a){
    a[0]=-1;
}

4、重载

  • 重载：在一个类中有相同的函数名，但形参不同

  • 重载的原则：

    方法名必须相同

    参数列表必须不同（个数、类型、排列顺序etc）

    方法的返回类型可以相同也可以不同

    仅仅返回类型不同不足以成为方法的重载

  • 方法名相同时，编译器会根据调用方法的参数个数、参数类型去匹配，不会根据返回值类型匹配，而是按照参数类型匹配完后将运算结果转换为返回值类型

  • main（）方法也可以传递参数，可以传递一个数组，但需要通过命令行传参

5、可变参数

  • 声明方法：int…x
  • 一个方法中只能有一个可变参数，且该可变参数必须为方法的最后一个参数，任何普通的参数必须在它之前声明
  • 可变参数本质是数组

以下两种传递参数的形式等价：

1
2
func(1,2,3,4,5);
func(new int[]{1,2,3,4,5});

即可变参数的本质是数组

Java数组

1、概述

  • 数组是相同类型数据的有序集合
  • 每一个数作为一个数组元素

2、数组声明创建

1
2
3
4
5
6
// 声明
int[] arr;//首选
int arr[];
// 定义
arr = new int[10];//开辟了10个int大小的内存空间

  • 通过索引来访问，索引从0开始

  • .length可以获取数组长度

  • 数值型数组自动初始化为0

Java内存分析（堆、栈、方法区）

JavaMemory

JavaMemory

注：除了8大基本类型，都是引用类型

数组的初始化

1
2
3
4
5
6
7
//静态初始化：创建+赋值
int [] a = {1,2,3,4,5};
int [] mens = {new man(10),new man(20)};
//动态初始化（就是先分配空间，日后再赋值，初始化）：包含默认初始化
int[] b= new int[10];
b[0] = 1;

默认初始化：数组也是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组的特点
  • 长度是确定的，数组一旦被创建，它的大小就不可以改变
  • 元素不允许出现混合类型
  • 数组中的元素可以是基本类型or引用类型，但必须同一类型
  • 数组变量属于引用类型，数组本身是对象，因此数组在堆中，声明的数组变量在栈中，指向堆中数组的地址
数组边界
  • 数组下标的合法区间 0-(length-1)

ArrayIndexOutOfBoundsException : 数组下标越界异常

3、数组使用

  • fori循环

  • For-Each循环，省去了下标

  • 数组作为函数参数

  • 数组作为函数的返回值

    1
    2
    3
    4
    int func(int[] func){}
    //数组作为参数
    int[] func(int x){}
    //数组作为返回值

4、多维数组

java里面打印某个东西，如果打出来一串x@xxxx，就是对象（数组也是对象，否则就是普通类型）

二维数组其实就是特殊的一维数组，数组的每一个元素都是数组（直接打a[0]得到一个对象，就是数组）

  • 二维数组的定义：

    1
    int[][] a = new int[2][3];

    以上的二维数组就可以看成一个两行三列的数组

    a[0] = [x，x，x]

    a[1] = [x，x，x]

    就是一维数组，只不过每个元素都是数组 [[x，x，x]，[x，x，x]]

    array

  • 二维数组的使用

    1、array.length 表示的是外层数组元素的个数，其实就是行数

    2、array[0].length 表示的是内层数组元素的个数，就是列数

  • 二维数组的遍历

    1
    2
    3
    4
    5
    int[][] array = {{1,2},{2,3},{3,4}}
    for(int i=0;i<array.length;i++)
        for(int j=0;j<array[0].length;j++){
            array[i][j].xxx;
        }

5、Arrays类

  • toString：把全部数组元素转换成一个字符串

    对于 a=[1,2] 会把a转换成一个 [1,2] 的字符串

  • sort：基于快排，不稳定

  • fill：填充

    重载1：fill(a，val)把a的所有元素填充为val

    重载2：fill(a，begin，end，val)把a的从begin到end-1下标的元素填充为val

  • 勤查JDK文档

6、冒泡排序（共8大排序）

java异常

0、异常概念

实际工作中，遇到的情况不可能是非常完美的。例如用户输入不符合要求、程序打开文件发现不存在，程序运行过程中内存或硬盘满了等

软甲程序在运行过程中，遇到这些异常的问题，我们叫做异常

👉Exception

1、异常分类

  • 检查性异常：

    通常是用户错误或问题引起的异常，这是程序员无法预见的。例如打开文件，文件丢失

  • 运行时异常：

    运行时出现的，可能被程序员避免

  • 错误：

    脱离程序员控制，例如递归栈溢出

2、异常体系结构（异常框架）（不完全）

3、Error

Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者无关

4、Exception

java异常—检查异常（checked exception）和未检查异常（unchecked exception

检查异常：编译器在编译的时候会检查

非检查异常：编译器不要求强制处置的异常，虽然有可能出错，但我不检查

非运行时异常：检查异常：不处理异常程序就不能编译通过

运行时异常：非检查异常：没有处理也能编译通过

处理：抛出or捕获

5、summary

Error通常是致命性的错误，是程序无法控制和处理的，当出现这种异常时，JVM通常会终止线程，要尽量避免

Exception通常是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

6、异常处理机制

异常处理分为：抛出异常和抓取异常

五个关键字：try catch finally throw throws

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
    //处理异常
public static void main(String[] args) {

    int a = 1;
    int b = 0;

    try {
        //try 内部为监控区域
        //System.out.println(a / b);
        a();
    } catch (ArithmeticException e) {//catch()中填想要捕获的异常类型
        System.out.println("b不能为0");
    } catch (Exception e) {
        System.out.println("Exception");
    } catch (Error t) {
        System.out.println("error");
    } catch (Throwable e) {
        System.out.println("Throwable");
    } finally {
        System.out.println("finally");
    }
    //finally处理善后工作（例如IO、资源等需要关闭）
    //可以不要finally！

    //多个catch类似else if，只能调用一个
    //从上到下：异常等级从子到父，或平级
}

static void a(){
    b();
}
static void b(){
    a();
}

快捷键：$.try$ 选中代码块$ctrl+alt+t$，快速生成异常处理 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//抛出异常
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        try {
            test(a,b);
        } catch (ArithmeticException e) {
            System.out.println("我还会继续执行，不信往下看");
        }
        System.out.println("我执行啦");
    }

    public static void test(int a,int b) throws ArithmeticException{

        if(b==0){
            throw new ArithmeticException();//一旦抛出异常，方法接下来的部分就不会被执行了
        }
        System.out.println(a/b);
        
    }
///

try {
    test(a,b);
} catch (Exception e) {
    System.out.println("我还会继续执行，不信往下看");
}

public static void test(int a,int b) throws ArithmeticException{
    int d = a/b;//如果自己不处理，则java在此处抛出异常后，下面也不会被执行，方法结束
    System.out.println(d);
   
}
//抛出的异常范围要小于等于捕获的异常范围

throw：用于在方法内部抛出异常

throws：用于从方法抛出异常

7、自定义异常

步骤：

1、创建自定义异常类

2、方法中throw抛出

3、要么在当前方法中处理，要么给方法的调用者处理。如果选择后者，要通过throws关键字抛出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MyException extends Exception{
    //1 异常处理逻辑
    private int detail;
    //传递数字>10
    public MyException(int a){
        this.detail = a;
    }
    //2 异常打印信息
    @Override
    public String toString() {
        return "MyException{" + detail + "}";
    }
}

public static void main(String[] args) {
    try {
        test(1);
    } catch (Exception e) {
        System.out.println(e.toString());
    }
}

public static void test(int a) throws Exception{
    if(a>10) {
        throw new MyException(a);
    }
    System.out.println("ok");
}

注：

1、catch语句是对异常的处理，你甚至可以不打印信息，只要把异常处理好就行了

如：对上面例子的改进

1
2
3
4
5
6
7
8
>int a = 11;
>try {
   test(a);
>} catch (Exception e) {
   a=a%10;
   //System.out.println(e.toString());
   System.out.println("ok, a has been done! a is " + a +" now");
>}

2、关于finally

如以下语句，都会被执行，finally中可以添加一些关闭资源(IO等)的逻辑

1
2
3
4
finally {
    System.out.println("finally is here");
}
System.out.println("除了finally我也可以被执行");

总结:

1、处理运行时异常时，采用合理的逻辑规避，同时辅助try catch处理

2、多重catch后面，可以加一个catch (Exception) 来处理可能会被遗漏的异常

3、对于不确定的代码，可以加上try catch，处理潜在的异常

4、尽量去处理异常，而不是简单地打印之

5、处理逻辑需要根据业务决定

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家