关于java:Java学习笔记01-JavaSE基础

在线工具

java https://c.runoob.com/compile/10

在线编写运行 Java 8 https://www.tutorialspoint.co…

SQL 在线运行 https://www.bejson.com/runcod…

Java 牛客题库 https://www.nowcoder.com/inte…

JDK, JRE, JVM

• JDK : Java Development Kit
• JRE : Java Runtime Enviroment
• JVM : Java Virtual Machine

输入 Hello Wolrd

vim Hello.java

public class Hello{public static void main(String[] args){System.out.print("Hello World!");
    }
}

编译

javac Hello.java

执行

java Hello

输入

Hello World!

Java 程序运行机制

• 编译型：
• 解释型：

• 程序运行机制：

  源文件(*.java) => Java 编译器 => 字节码(.class)

  => JVM (类装载器 => 字节码校验器 => 解释器)

  => 操作系统平台

IDEA

新建工程

File => New => Project… => Empty Project

File => Project Structure => Project => Project SDK (1.8.0) => Project language level (8) => OK

根底语法

1. 正文，标识符，关键字

正文

// 单行正文
/* 多行正文 */
/**
  * 文档正文
  * @Author itxiaoma
  */

标识符

类名，变量名，办法名都称为标识符

• 标识符以字母，美元 ($)，下划线(_) 开始
• 首字母后能够是字母，美元($)，下划线(_)，数字的组合
• 不能应用关键字作为变量名，办法名
• 大小写敏感

关键字(50+)

2. 数据类型

强类型语言：变量应用必须严格符合规定，所有变量都必须先定义后能力应用

Java 数据类型

1. 根本类型：（8 大根本类型）

   1. 数值

      1. 整数

         1. byte：1 个字节（-128~127）
         2. short：2 个字节（-32768~32767）
         3. int：4 个字节（-2147483648~2147483647）21 亿 +
         4. long：8 个字节（例：long num=40L;）

      2. 浮点

         1. float：4 个字节（例：float num=40F;）
         2. double：8 个字节
      3. 字符串 char：2 个字节
   2. boolean：1 位，true/false

2. 援用类型：类，接口，数组

注 1：String 不是数据类型，是类

注 2：1bit 示意 1 位；（bit 是计算机外部数据存储的最小单位）

​ 1Byte 示意 1 个字节，1B=8b；

​ 1KB = 1024B；

​ 1MB = 1024KB；

​ 1GB = 1024MB；

​ 1TB = 1024GB；

Java 数据类型的常见问题

1. 整数扩大

   int a = 10;
   int b = 010;// 八进制
   int c = 0x10;// 十六进制

2. 浮点型扩大

   float f = 0.1f;
   double d = 1.0/10;
   System.out.println(f==d);//false
   
   float d1 = 123123123123f;
   float d2 = d1 + 1;
   System.out.println(d1==d2);//true
   
   //float 无限 离散 舍入误差 靠近但不等于
   // 不要用浮点数进行比拟
   // 数学工具类 BigDecimal

3. 字符类扩大

   char a = 'a';
   System.out.println((int)a);//97
   char a1 = '\u0061';
   System.out.println(a1);//a
   // 所有的字符实质还是数字
   
   转义字符:
   \t 制表符
   \n 换行
   ...

3. 类型转换

运算中，不同类型的数据会先转换位同一类型，再进行计算

优先级：低 ==> 高

byte,short,char => int => long => float => double

主动转化：低 => 高

强制转换：高 => 低 (类型)变量名

注 1：

1. 不能对布尔值进行转换
2. 不能把对象类型转为不相干的类型
3. 高容量转低容量，会有内存溢出或精度问题

注 2：JDK7 的新个性，数字间能够用下划线宰割(1000 = 1_000)

4. 变量、常量、作用域

变量

int a = 1;

常量 – final

常量：初始化后不能扭转，个别为大写

static final double PI = 3.14;

作用域

1. 类变量
2. 实例变量
3. 局部变量

public class Hello {
    // 类变量：static
    static int a = 1;
    // 实例变量：属于对象，不须要初始化(会主动初始化为类型默认值)
    // 布尔值默认 false，除根本类型以外其余变量都是 null
    String b;
    public static void main(String[] args) {System.out.println(a);

        int c = 3;// 局部变量：必须申明和初始化
        System.out.println(c);

        Hello obj = new Hello();
        System.out.println(obj.b);//null
    }
}

命名规定：

1. 类变量，局部变量，办法名：驼峰（首字母小写）
2. 常量：大写 + 下划线
3. 类型：驼峰（首字母大写）

5. 根本运算符

1. 算术运算符：+, -, *, /, %, ++, —
2. 赋值运算符：=
3. 关系运算符：>, <, >=, <=, ==, !=, instanceof
4. 逻辑运算符：&&,||,!
5. 位运算符：&, |, ^, ~, >>, << , >>>
6. 条件运算符：? :
7. 扩大赋值运算符：+=, -=, *= ,/=

例：

long a = 123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+d);//long
System.out.println(b+c);//int
System.out.println(c+d);//int
// 论断：有 long 类型时转 long，否则转 int

幂运算：2^3

double pow = Math.pow(2, 3);
System.out.println(pow);//8.0

位运算

<< 乘 2 
>> 除 2 

6. 包机制

包的实质就是文件夹

1. 包机制是为了更好地组织类，用于区别类名的命名空间
2. 个别用公司名倒置作为报名 pakage com.baidu.www;
3. 应用 import 导入包（import 包名.* 示意导入包下所有类）

7.JavaDoc 生成文档

正文参数

/**
 * @author 作者
 * @version 版本
 * @since 须要最早应用的 jdk 版本
 * @param 参数
 * @return 返回值
 * @throws 异样抛出
 */

中文编码

javadoc -encoding UTF-8 -charset UTF-8 Demo.java

流程管制

1. 用户交互 Scanner (Java5 新个性)

根底应用

import java.util.Scanner;

public class Demo {public static void main(String[] args) {
        // 创立扫描器对象，用于接管键盘数据
        Scanner s = new Scanner(System.in);
        // 判断用户输出
        if(s.hasNextLine()){String str = s.nextLine();
            System.out.println(str);
        }
        //IO 流的类会始终占用内存，用完须要敞开
        s.close();}
}
//next()以空格为结束符，nextLine()以回车为结束符

应用进阶

计算多个数字的总和与平均数，非数字完结

Scanner s = new Scanner(System.in);
double sum = 0;
int num = 0;
while(s.hasNextDouble()){double x = s.nextDouble();
    sum += x;
    num++;
}
System.out.println("和是：" + sum);
System.out.println("平均值是" + (sum/num));
s.close();

2. 九九乘法表

/*
1*1=1    
2*1=2    2*2=4    
3*1=3    3*2=6    3*3=9    
4*1=4    4*2=8    4*3=12    4*4=16    
5*1=5    5*2=10    5*3=15    5*4=20    5*5=25    
6*1=6    6*2=12    6*3=18    6*4=24    6*5=30    6*6=36    
7*1=7    7*2=14    7*3=21    7*4=28    7*5=35    7*6=42    7*7=49    
8*1=8    8*2=16    8*3=24    8*4=32    8*5=40    8*6=48    8*7=56    8*8=64    
9*1=9    9*2=18    9*3=27    9*4=36    9*5=45    9*6=54    9*7=63    9*8=72    9*9=81    
*/
for (int m = 1; m <= 9; m++) {for (int n = 1; n <= m; n++) {System.out.print(m + "*" + n + "=" + (m * n) + "\t");
    }
    System.out.println();}
//System.out.print 不换行输入

3. 加强 for 循环(JDK1.5 新个性)

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

4.label

打印 101 – 150 间的所有质数

outer:for (int i = 101; i <= 150; i++) {for (int j = 2; j < i / 2; j++) {if (i % j == 0) {continue outer;}
    }
    System.out.println(i);
}

Java 办法

办法是用来实现特定性能的代码片段，由办法名和办法体组成

办法名：修饰符 返回值类型 办法名（参数类型 参数名）{}

办法体：return 返回值;

参数类型：实参，形参

注：java 都是值传递，没有援用传递

1. 办法的重载

重载就是在一个类中，有雷同的函数名称，但形参不同的函数

办法重载规定：

1. 办法名称必须雷同
2. 参数列表必须不同（个数，类型，参数程序不同）
3. 返回类型可雷同可不同

2. 命令行传参

程序运行时传递参数，能够通过 main 办法传递

public static void main(String[] args) {for (int i = 0; i < args.length; i++) {System.out.println(args[i]);
    }
}

3. 可变参数(JDK1.5 新个性)

public static void main(String[] args) {test(1,2,3);
}
public static void test(int... i){System.out.println(i[0]);
    System.out.println(i[1]);
    System.out.println(i[2]);
}

4. 递归

递归头：什么时候不调用本身办法。如果没有头，将陷入死循环。

递归体：什么时候须要调用本身办法。

Java 数组

数组是雷同类型数据的有序汇合

dataType[] arrayRefVar = new dataType[size];

int nums[] = new int[10];
// 二维数组
int[][] n = new int[2][2];
int[][] n = {{1,2},{3,4}} 

根本特点

1. 长度是确定的，一旦创立，长度不可变
2. 元素类型必须雷同
3. 数组对象自身在堆中（数组是援用类型，可看做对象，数组元素相当于对象的成员变量，Java 的对象在堆中）

内存剖析

graph LR
A(java 内存)
A --> B(堆)
      B -->B1[寄存 new 的对象和数组]
      B -->B2[能够被所有线程共享, 不会寄存别的对象援用] 
A --> C(栈)
      C -->C1[寄存根本变量类型, 蕴含具体数值]
      C -->C2[援用对象的变量, 寄存援用在堆中的地址] 
A --> D(办法区)
      D -->D1[能够被所有线程共享]
      D -->D2[蕴含所有 calss 和 static 变量] 

//1. 申明数组
int[] nums;// 在栈中
//2. 创立数组
nums = new int[10];// 在堆中

三种初始化状态

// 动态初始化
int[] a = {1, 2, 3};
Man[] mans = {new Man(1),new Man(2)}

// 动静初始化(蕴含默认初始化)
int[] b = new int[10];// 默认调配 10 个 0
b[0] = 10;

注：数组是援用类型，数组元素相当于类的实例变量，数组创立时调配空间，数组元素也会按默认值初始化。

数组工具类 java.util.Arrays

冒泡排序

1. 共有八大排序
2. 工夫复杂度为 O(n2)

稠密数组

当一个数组中大部分元素为 0 或值雷同时，能够应用稠密数组保留

解决形式：

1. 记录数组行列数，不同值数

2. 把不同值的元素行列信息，元素值记录在小规模数组中

/*
稠密数组
1    2    1
2    3    2
还原数组
0    0    0    0    0    0    0    0    0    0    0    
0    0    1    0    0    0    0    0    0    0    0    
0    0    0    2    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
0    0    0    0    0    0    0    0    0    0    0    
*/
public class Demo {public static void main(String[] args) {int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        int sum = 0;
        for (int i = 0; i < 11; i++) {for (int j = 0; j < 11; j++) {if (array1[i][j] != 0) {sum++;}
            }
        }
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        int count = 0;
        for (int i = 0; i < array1.length; i++) {for (int j = 0; j < array1[i].length; j++) {if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("稠密数组");
        for (int j = 1; j < array2.length; j++) {System.out.println(array2[j][0] + "\t" + array2[j][1] + "\t" + array2[j][2]);
        }
        System.out.println("还原数组");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int j = 1; j < array2.length; j++) {array3[array2[j][0]][array2[j][1]] = array2[j][2];
        }
        for (int[] ints : array3) {for (int num : ints) {System.out.print(num + "\t");
            }
            System.out.println();}
    }
}

面向对象

以类的形式组织代码。以对象组织 (封装) 数据

三大个性：封装，继承，多态

1. 创立类与对象

一个我的项目应该只存在一个 main 办法

创建对象

应用 new 创建对象时，除了分配内存空间，还会给创立好的对象进行默认初始化，及调用类中的结构器。

com/oop/demo/Application.java

package com.oop.demo;
public class Application {public static void main(String[] args) {
        // 类：形象的，实例化后会返回一个本人的对象
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 20;
        xiaohong.name = "小红";
        xiaohong.age = 21;
        System.out.println("姓名：" + xiaoming.name + "\t 年龄：" + xiaoming.age);
        xiaoming.study();
        System.out.println("姓名：" + xiaohong.name + "\t 年龄：" + xiaohong.age);
        xiaohong.study();}
}

com/oop/demo/Student.java

package com.oop.demo;
public class Student {
    // 属性
    String name;
    int age;
    // 办法
    public void study() {System.out.println(this.name + "在学习");
    }
}

结构器(构造方法)

1. 必须和类名雷同
2. 必须没有返回类型（不能写 void）
3. 一旦定义了有参数的结构器，new 对象时想不传参数，就必须写一个无参数结构器

public class Student {
    // 属性
    String name;
    int age;
    // 无参 (默认) 结构器
    public Student(){}
    // 有参
    public Student(String name){this.name = name;}
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    } 
}

创建对象内存剖析

public class Application {public static void main(String[] args) {
        // 类：形象的，实例化后会返回一个本人的对象
        Student xiaoming = new Student();
        Student xiaohong = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 20;
        xiaohong.name = "小红";
        xiaohong.age = 21;
        System.out.println("姓名：" + xiaoming.name + "\t 年龄：" + xiaoming.age);
        xiaoming.study();
        System.out.println("姓名：" + xiaohong.name + "\t 年龄：" + xiaohong.age);
        xiaohong.study();}
}

办法区也在堆中；

静态方法区和类一起加载，所以静态方法能够间接调用，不须要实例化

1. 加载 Application 和 Student 类信息到办法区
2. 加载 main()办法到栈中
3. 加载 xiaoming 和 xiaohong 援用变量名到栈中
4. 加载 Student xiaoming = new Student(); 和 Student xiaohong = new Student(); 实例到堆中
5. xiaoming 和 xiaohong 调用办法区的 study 办法

注：根本类型外的变量都是援用类型，是通过援用来操作的；援用名在栈中，指向对象实体在堆中的地址。

封装

禁止间接拜访一个对象中数据的理论示意，应通过接口操作来拜访。

属性公有(private)，get/set

public class Student {
    private String name;
    private int age;
    public String getName() {return this.name;}
    public void setName(String name) {this.name = name;}
    public void setAge(int age) {this.age = age;}
    public int getAge() {return age;}
}

继承 extends

继承的实质是对某一批类的形象，从而实现更好的建模；

继承是类之间的关系，子类继承 (extends) 父类的全副 public 办法；

公有的属性和办法无奈被继承

注：

1. Java 中只有单继承，没有多继承（一个子类只能有一个父类）
2. Java 中所有类，都默认间接或间接继承 Object 类

Super

留神点

1. super 调用父类的构造方法，必须在构造方法的第一行
2. super 只能呈现在子类的办法或构造方法中
3. super 和 this 不能同时在构造方法中调用（都须要在第一行）

super 和 this 的区别

com/oop/demo/Application.java

package com.oop.demo;

public class Application {public static void main(String[] args) {Student xiaoming = new Student();
        xiaoming.test1();
        //Person 无参结构
        //Student 无参结构
        //Student
        //Student
        //Person
    }
}

com/oop/demo/Person.java

package com.oop.demo;

public class Person {public Person() {System.out.println("Person 无参结构");
    }
    public void print(){System.out.println("Person");
    }
}

com/oop/demo/Student.java

package com.oop.demo;

public class Student extends Person{public Student() {// 暗藏代码：调用了父类的无参结构 super();
        //super();
        System.out.println("Student 无参结构");
    }
    public void print(){System.out.println("Student");
    }
    public void test1(){print();
        this.print();
        super.print();}
}

办法重写 @Override

子类的办法和父类必须要统一，办法体不同

重写都是办法的重写，和属性无关

静态方法不能被重写 !

留神点

1. 办法名，参数列表必须雷同
2. 修饰符范畴能够扩充不能放大
3. 抛出异样范畴能够放大不能扩充

代码示例

静态方法

public class B {public static void test(){System.out.println("B=>test()");
    }
}
public class A extends B{public static void test(){System.out.println("A=>test()");
    }
}
public class Application {public static void main(String[] args) {
        // 静态方法：办法调用只和右边定义的数据类型无关
        A a = new A();
        a.test();//A=>test()
        // 父类的援用指向了子类
        B b = new A();
        b.test();//B=>test()
    }
}

办法重写

public class B {public void test(){System.out.println("B=>test()");
    }
}
public class A extends B{
    @Override
    public void test() {System.out.println("A=>test()");
    }
}
public class Application {public static void main(String[] args) {A a = new A();
        a.test();//A=>test()
        B b = new A();
        b.test();//A=>test()
    }
}

多态

同一办法依据发送对象不同，采纳多种不同的行为形式；

一个对象的类型是确定的，但能够指向对象的援用类型有很多（能够是子类，父类，Object）

多态存在的条件：

1. 有继承关系
2. 子类重写父类办法
3. 父类援用指向子类对象

注：多态是办法的多态，属性没有多态。

无奈重写的办法

1. static 办法，属于类，不属于实例
2. final 常量 (final 润饰的类不能被继承)
3. private 办法

// 子类能调用的办法都是本人的或继承父类的
A a = new A();
B b = new B();
// 对象能执行哪些办法看右边的援用类型
// 父类援用能够指向子类，但不能调用子类独有的办法
B c = new A();
a.test();//A=>test()
b.test();//B=>test()
// 子类重写了父类办法，会执行子类的办法
c.test();//A=>test()

instanceof 和类型转化

1. 父类援用能够指向子类的对象，反过来不行
2. 子类转换为父类称为向上转型，可能失落本人原本的一些办法
3. 父类转换为子类称为向下转型，须要强制转换

public class Application {public static void main(String[] args) {
        // 子类特有办法 go
        Student s = new Student();
        s.go();
        // 向上转型，转型后无奈再调用 go 办法
        Person p = s;
        // 向下转型
        ((Student) p).go();}
}

static 关键字

动态变量

private static int age;

静态方法

public class Application {private static void test(){System.out.println("Static Function");
    }
    public static void main(String[] args) {test();
    }
}

动态代码块

public class Person {
    {System.out.println("匿名代码块");
    }
    static {System.out.println("动态代码块");// 只会在类加载时执行一次
    }
    public Person() {System.out.println("构造方法");
    }
    public static void main(String[] args) {Person p = new Person();
        // 动态代码块
        // 匿名代码块
        // 构造方法
    }
}

动态导入包

import static java.lang.Math.random;
public class Person {public static void main(String[] args) {System.out.println(random());
    }
}

抽象类 abstract

// 抽象类 (接口能够多继承)
abstract class Person {public abstract void doSomething();// 形象办法：只有办法名，没有办法体
}

注：

1. 抽象类不能 new，只能靠子类实现
2. 形象办法必须在抽象类中，但抽象类能够蕴含一般办法

接口 interface

对对象的形象，束缚和实现拆散：面向接口编程

注：

1. 接口不能被实例化，接口中没有构造方法
2. 接口中所有办法都是形象的(public abstract)
3. 接口中只有常量(public static final)
4. 类通过 implements 实现接口，一个类能够实现多个接口，实现多继承
5. 实现接口的类，必须重写接口中所有办法

public interface UserService {void userTest1();
    void userTest2();}
public interface TimeService {void time1();
    void time2();}
public class UserTime implements UserService,TimeService{
    @Override
    public void userTest1() {}
    @Override
    public void userTest2() {}
    @Override
    public void time1() {}
    @Override
    public void time2() {}
}

外部类

匿名对象：不将实例保留到变量 (栈) 中，只在堆内存中应用对象

public class Application {public static void main(String[] args) {new Apple().eat();}
}
class Apple{public void eat(){System.out.println("吃苹果");
    }
}

匿名外部类

public interface UserService {void userTest1();
    void userTest2();}
public class Application {UserService u = new UserService() {
        @Override
        public void userTest1() {}
        @Override
        public void userTest2() {}
    };
}

异样 Error Exception

Error

Error 类对象由 JVM 生成并抛出，大多数谬误与操作无关，产生谬误时 JVM 个别会终止线程；

如内存溢出(OutOfMemeryError)，栈溢出，类定义谬误(NoClassDefFoundError)，链接谬误(LinkageError)

Exception

异样通常由逻辑谬误引起，应尽量避免

1. 非运行时异样(IO 异样 …)
2. 运行时异样(RuntimeException)

注：Error 通常是致命性谬误，程序无奈解决；Exception 通常能够且应该尽可能的解决。

异样解决机制

1. try 监控区域（必要）
2. catch 捕捉异样 (必要)
3. finally 最终解决 (开释占用资源)
4. throw 抛出异样(个别在办法中应用)
5. throws

注：捕捉多个异样须要从小到大 XXXException < XXXException < Throwable

public class Application {public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try{if(b == 0){throw new ArithmeticException();
            }
            System.out.println(a/b);
        }catch (ArithmeticException e){e.printStackTrace();// 打印谬误的栈信息
        }catch (Exception e){}catch (Throwable e){}finally {}
    }
}

自定义异样

用户自定义异样类，只须要继承 Exception 类即可

public class MyException extends Exception {
    String msg;

    public MyException(String msg) {this.msg = msg;}

    @Override
    public String toString() {return "MyException{" + msg + "}";
    }
}
public class Application {static void test(String msg) throws MyException{throw new MyException(msg);
    }
    public static void main(String[] args) {
        try{test("test");
        }catch (MyException e){System.out.println(e);//MyException{test}
        }
    }
}