JavaSE

前提

​ Java相当于C++ - -，是因为JVM接管了用户的指针和内存管理。Java分三种JavaSE、JavaME、JavaEE（ edition）。

​ 配置环境：JAVA_HOME – D:\Environment\Java\jdk1.8.0_05。PATH – %JAVA_Home%\bin、%JAVA_Home%\jre\bin。查看：cmd：java -version。

​ JDK > JRE > JVM。

NON-NLS-1$的含义 就 是non need localize string 的缩写。

jdk文件夹:

• bin存可执行文件例如java.exe和javac.exe。
• include包含c语言的头文件。
• lib存放的是jar包库文件
• src.zip\java是存放Java库的核心代码(.java)
• jre\lib\rt.jar是运行时核心代码，同上（.class）

rt.jar：

• text、beans、security
• rmi：RMI（Remote Method Invocation，远程方法调用），它大大增强了Java开发分布式应用的能力
• nio(new)区别于io：io存在buffer中，线程非阻塞。而io，在读取时，线程阻塞、io
• applet，Apple是采用Java编程语言编写的小应用程序，该程序可以包含在 HTML（标准通用标记语言的一个应用）页。

基本代码

第一个代码

public class Hello{			//新建Hello类
	public static void main(String[] args){  //主函数main,args是arguments的缩写
		System.out.print("hello ,world");
	}
}

（DOS操作）cmd：

#提前写好Hello.txt后改Hello.java
#cmd
javac Hello.java   #生成Hello.class字节码文件			
java Hello		  #输出hello world		//自动找寻.class字节码文件

​ 使用 java 命令，将源文件（.java）编译成对应的字节码文件（.class）。字节码文件是二进制流文件。字节码文件非常紧凑，在JVM中占用少量的内存。每个类（或者接口）都单独占据一个字节码文件。类中所有信息都在字节码文件中有所描述，由于字节码文件非常灵活，它对类的描述能力甚至强于java源文件。

cmd：

#编写ForOut.txt之后ForOut.java
public class ForOut {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
#cmd
E:\test>javac ForOut.java

E:\test>java ForOut zhang qing lin
args[0]:zhang
args[1]:qing
args[2]:lin

数据类型：

• 基本类型：8大基本类型。
• 引用类型：数组，类，接口。

数字&字符：

int a = 100;
(short)a		//强转

System.out.println((int)12.4);   //12
System.out.println((int)-13.4);		//-13，直接去尾即可

char c1 = 'a';		//字符用单引号
int a = c1+1;
System.out.println(a);			//98
System.out.println((char)a);    //输出b 

char c = '\u0061';			//字符为两个字节
System.out.println(c);		//a
System.out.println('\u0061');	//a

变量赋值：

int money = 10_0000_0000;	//数字多的话可以加下划线
int years=20;
System.out.println(money);          

long total1 = years*money;//越界
long total2 = (long)money*years;//正确

变量作用域：

• 局部变量：main或者方法里的变量
• 实例变量：无static
• 类变量：static

public class Test {
    static final String name="adair";//类常量
    static int score= 100;  //类变量
    int money;//实例变量

    public static void main(String[] args) {
        Test test = new Test();
        test.money = 100;

        System.out.println(name);	//adair。在类里面直接使用
        System.out.println(Test.name);
        System.out.println(test.name);
        System.out.println(test.money);
    }
}

运算符：

• 算数运算符：加减乘除，商余，++，- -
• 赋值运算符
• 关系运算符
• 逻辑运算符，与或非
• 位运算符& | ^ ~ << >>
• 条件运算符? ：
• 扩展赋值运算符

基本运算：

double pow = Math.pow(2,3);//不用import static java.lang.Math.pow;
System.out.println(pow);

boolean a =true;
boolean b = false;
System.out.println("a && b: "+(a&&b));

char a = 5;
System.out.println(a++<6);  //先比较，再自增

int a=10;
int b=20;
System.out.println(""+a+b);         //1020
System.out.println(a+b+"");         //30

JavaDoc命令：生成api文档@auther,version,since,param,return,throws

public class Test {
    String name;
  /**                            //输入/**回车即可自动生成
     * 
     * @param name
     * @return
     * @throws Exception
     */

  public String test(String name) throws Exception{
        return name;
    }
}
#cmd生成帮助文档
javadoc -charset utf-8 -encoding utf-8  Test.java

输入：

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int sum = 0;
        while (scanner.hasNextInt()){
            int temp = scanner.nextInt();   //得到输入的数字
            sum += temp;
            System.out.println("sum:"+sum);
        }
        //凡是属于IO流的类，如果不关闭会一直占用资源
		scanner.close();  
    }
}

提示：hasnext()表示有空格后面的就不要了。hasnextline()以回车为结束符，空格也会当成回车处理。

Scanner scanner = new Scanner(System.in);
if(scanner.hasNextLine()){
    String str = scanner.nextLine();
    System.out.println(str);
}
//凡是属于IO流的类，如果不关闭会一直占用资源
scanner.close();   

switch：

char grade = 'B';
switch (grade){	//string类型也可以
    case 'A':
        System.out.println("优秀");break;		//没有break会case穿透
    case 'B':
        System.out.println("良好");break;
    default:
        System.out.println("不知道");
}

​

​ 流程控制：顺序，选择，循环（break，continue，标签）。

outer: for (int i = 2; i < 1000; i++) {		//标签设置
        continue outer;
}

注释：

//行内注释

/*
多行注释
*/

/**文档注释：javadoc生成帮助文档
*
*/

​ 包机制简述：。

​ 标识符 vs 关键字：。

​ 类型转换：高到低，低到高。

Method

​ 重载 vs 重写：简述区别。

使用method：

• 类名.方法名：需要static修饰此方法。
• 对象.方法名

​ Person student = new Student();student.test()：如果test()动态则使用Student.test()，如果test()静态，使用Person.test()。

​ 子类继承抽象类或者实现接口，必须实现全部的abstract修饰的方法。

可变参数：

#int...nums;则nums可变参数，可以看作数组
public class Test {
    public static void main(String[] args) {
        output(2,3,4,5,6,7);
    }
    public static void output(int...nums){	//固定参数必须要放到可变参数之前
        for (int num : nums) {			//sout(Arrays.toString(nums))
            System.out.println(num);
        }
    }
}

数组：(成员也可是应用变量)

public class Test {
    public static void main(String[] args) {
        int[] nums={2,3,4,7,5};	

        System.out.println(nums);//[I@7ea987ac

        Arrays.sort(nums);//通过方法对nums操作：排序
        System.out.println(Arrays.toString(nums));
    }
}
#总结：Arrays中的静态方法直接使用
Arrays.sort(nums);
Arrays.toString(nums)

Class

​ OOP vs POP vs FP。java/C++是OOP，C是POP

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

• 封装：利用private，然后set/get
• 继承 ：单继承
• 多态：父类的引用指向子类对象，可以用stanceof判断是否可以类型转换。

范围：

	类内部	本包	子类	外部包
public				√
protected			√
default		√
private	√

​ new对象的本质就是在调用构造器。有参构造→(必有)→无参构造。super和this不可同时在构造器。

InnerClass

• 种类：静态内部类，匿名内部类(监听事件)，成员内部类，局部内部类
• 极其精简：lambda
• 成员内部类：

public class OuterClass {
    private String outerName;
    public void display(){
        System.out.println("OutClass display");
        System.out.println(outerName);
    }
    
    public class InnerClass{
        private String innerName;
        public InnerClass() {
            innerName = "inner name";
        }
        public void display(){
            System.out.println(" InnerClass display");
            System.out.println(innerName);
        }
    }
    
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();//成员内部类
        innerClass.display();
    }
}

• 局部内部类(在方法内部，调用方法即可)：

public class OuterClass {
    private String outerName;
    public void display(){
        class InnerClass{        //局部内部类，外部类直接调用方法即可
            public void print(){
                System.out.println("method inner class");
            }
        }
        new InnerClass().print();
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

• 静态内部类：

public class OuterClass {
    private String outerName;
    //外部方法
    public void display(){
        System.out.println("OutClass display");
        System.out.println(outerName);
    }
    public static class InnerClass{
        private String innerName;
        public InnerClass() {
            innerName = "inner name";
        }
        public void display(){
            System.out.println(" InnerClass display");
            System.out.println(innerName);
        }
    }

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        OuterClass.InnerClass innerClass = new InnerClass();//类型也可是InnerClass
        innerClass.display();
    }
}
#成员内部类,静态内部类：是否有static,静态内部类不要先创建外部类
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
OuterClass.InnerClass innerClass = new InnerClass();

• 匿名内部类（eg用于监听）

public interface MyInterface {
    public void test();
}
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test1");
    }
}
public class Test {
	public static void main(String[] args) {
        MyInterface myInterface1 = new MyImplement();//接口类型指向实现类
        myInterface1.test();

        //new 接口(){匿名累内部类}
        MyInterface myInterface2 = new MyInterface() {
            @Override
            public void test() {
                System.out.println("test2");
            }
        };
        myInterface2.test();
    }
}

重写（动态method）：

public class Test {
    public static void main(String[] args) {
        Person student = new Student();//父类的引用指向子类
        student.test();    //输出Student。执行子类的方法

    }
}
public class Person {
    public void test(){
        System.out.println("Person");
    }
}
public class Student extends Person{
    @Override
    public void test() {
        System.out.println("Student");
    }
}

instanceof：

public class Test {
    public static void main(String[] args) {
        Object os = new Student();
        System.out.println(os instanceof Object);//1
        System.out.println(os instanceof Person);//1
        System.out.println(os instanceof Student);//1
        System.out.println(os instanceof Teacher);//0
        System.out.println(os instanceof String);//0

        Person ps = new Student();
        System.out.println(ps instanceof Object);//1
        System.out.println(ps instanceof Person);//1
        System.out.println(ps instanceof Student);//1
        System.out.println(ps instanceof Teacher);//0
//        System.out.println(ps instanceof String); //报错

        Student ss = new Student();
        System.out.println(ss instanceof Object);//1
        System.out.println(ss instanceof Person);//1
        System.out.println(ss instanceof Student);//1
//        System.out.println(ss instanceof Teacher); //报错
//        System.out.println(ss instanceof String);  //报错

    }
}

• 父子类型，父高子低。父转化为子，强制

Teacher th=new JavaTeacher();

Teacher th=new JavaTeacher();
JavaTeacher jt = (JavaTeacher)th;	//父类到子类，强制。子到父，自动

static代码块，空代码块，构造器：

public class Test {
    static {
        System.out.println("static代码块");
    }
    {
        System.out.println("空代码块");
    }
    public Test(){
        System.out.println("构造器");
    }
    public static void main(String[] args) {
        Test t1 = new Test();//static代码块   空代码块    构造器

        Test t2 = new Test();// 空代码块    构造器
    }
}

random：

public class Test {
    public static void main(String[] args) {
        //需要import static java.lang.Math.random;同pow类似
        System.out.println(random());
    }
}

抽象类：

public abstract class A {		//定义抽象类
    public abstract void test();
}
public class B extends A{		//继承抽象类
    @Override
    public void test() {	方法体	 }	//实现抽象方法
}

OO的精髓是接口

泛型

基本：

ArrayList<String> str = new ArrayList<String>();
str.add("aaa");
ArrayList<Integer> integers = new ArrayList<>(10);
integers.add(10);

泛型类：

public class Generic<T>{ //外部指定
    private T key;
    public Generic(T key) { 
        this.key = key;
    }
    public T getKey(){ 
        return key;
    }
}

泛型接口：

public class Demo {
    public static void main(String[] args) {
        System.out.println(new MyImplement("zhangsan").test());
    }
}
class MyImplement implements MyInterface<String>{
    private String str;
    public MyImplement(String str) {
        this.str = str;
    }
    @Override
    public String test() {
        return str;
    }
}
interface MyInterface<T>{
    T test();
}

Exception

throwable：exception(检查时，运行时)和error。ERROR是致命的（JVM引起的OOM,StackoverFlowError）。Exception是可被catch。

抛出异常，捕获异常：

public class Test {
    public static void main(String[] args) {
        try{
            System.out.println(1/0);	//ctrl+alt+T快速生成
        }catch (ArithmeticException e){             //不走
            System.out.println("ArithmeticException:b不可为0");
        }catch (Exception e){
            System.out.println("Exception:b不可为0");  //ArithmeticException:b不可为0
        }finally {
            System.out.println("结束");
        }
    }
}

函数抛出异常：

public class Test {
    public static void main(String[] args) {
        try {
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            System.out.println("抛出ArithmeticException");
        }
    }
    public void test(int a, int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//new 一个算数异常
        }
    }
}

自定义异常类：

public class Test {
    public static void main(String[] args) {
        try {
            test(0);
        } catch (MyException e) {
            System.out.println(e);
        }
    }
    public static void test(int a) throws MyException{
        if(a==0){
            throw new MyException();		//如果有构造器的话，还可以传递值
        }
    }
}
class MyException extends Exception{
    @Override
    public String toString() {
        return "wrong";
    }
}

tips：异常 = 运行时异常 + 非运行时异常(编译异常)。非运行时异常：IOException、SQLException，必须处理否则无法编译，例如用catch捕获。

常用类

Integer

包装类：

int a = 10;
//装箱：基本类型→引用类型
Integer integer = new Integer(a);
Integer integer1 = Integer.valueOf(a);//valueOf是静态方法,-128~127是同一地址(Integer缓冲区)
//拆箱：引用类型→基本类型
int i = integer.intValue();

//JDK1.5之后，自动装箱，自动拆箱
Integer integer2 = a;
int a1 = integer2;
==============================================
Integer integer = new Integer(100);
Integer integer1 = new Integer(100);
System.out.println(integer == integer1);    //false。因为是不同的对象

Integer integer2 = 100; //Integer.Valueof(100),返回cache中的相同对象
Integer integer3 = 100;
System.out.println(integer2 == integer3);    //true

Integer integer4 = 200; //超出int的cache，new Integer(200)
Integer integer5 = 200;
System.out.println(integer4 == integer5);    //false

Integer类的方法：

============Integer→String==========
int i = 100;
String s = 100 + "";	//转换成字符串
String s1 = Integer.toString(i);    //转换成字符串
String s2 = Integer.toString(15, 16);   //s2="f"
String s3 = Integer.toHexString(15);    //同上
============String→Integer==========
String s = "100";
int i = Integer.parseInt(s);
String s1 = "true";
boolean b = Boolean.parseBoolean(s1);

String

String类：

String name = "adair";//name指向方法区，字符串池的内容“adair”
name="zhangsan";//没有修改数据，而是重新开辟了一片空间，name再次指向这个空间
String name1 = "zhangsan";  //name1和name同时指向“zhangsan”

//在方法区"java"，堆"java"两个对象，堆指向方法区，归根还是一个存储
String str = new String("java");
String str1 = new String("java");
System.out.println(str1 == str);    //地址不同

============常用方法================
String s = "java是比较好的语言";
System.out.println(Arrays.toString(s.toCharArray()));//单独每个字符

String s = "java is,the   best";
String[] strings = s.split(" |,");//以空格和逗号分割字符串
for (String string : strings) {
System.out.println(string);
}

String s = "java is the best";//每个首字母大写
String[] s1 = s.split(" ");
for (String s2 : s1) {
    char c =(char) (s2.charAt(0) - 32);	
    System.out.print(c + s2.substring(1)+"\t");
}

#Character类的方法
Character.toUpperCase(c);

• StringBuffer：多线程 效率低（安全）。
• StringBuilder：单线程 效率高（不安全）。

StringBuffer sb = new StringBuffer();//new StringBuilder();
sb.append("hello");
sb.insert(0,"nihao");
sb.delete(0,5);
sb.delete(0,sb.length());

• StringBuilder和StringBuffer都是比String节约时间的

BigDecimal

double a = 1.0; //double存储的就不是0.1
double b = 0.9;
System.out.println(a - b);//0.09999999999999998
System.out.println((1.4 - 0.5) / 0.9);//0.9999999999999999

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
BigDecimal subtract = bd1.subtract(bd2);//add,multiply,divide
System.out.println(subtract);   //0.1

BigDecimal divide = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(divide);     //1

//除不尽，如果不四舍五入的话，报错
BigDecimal divide1 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
System.out.println(divide1);    //3.33

Date

• 目前很少用，如今使用Calendar

• Unix：1970/1/1 0:0:0 GMT

System.out.println(new Date());	//Mon Mar 27 23:02:12 CST 2023
System.out.println(new Date().toLocaleString());//2023-3-27 23:03:23
System.out.println(new Date().getTime());//1970开始的mm

Date date1 = new Date();
//date2.after(date1);
//after,before,compareTo

Calendar

//Calendar是抽象类，需要通过静态方法getInstance()获取calendar
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime()); //Fri Apr 15 14:53:18 CST 2022
System.out.println(calendar.getTimeInMillis());//1970年
System.out.println(calendar.get(Calendar.YEAR));

Calendar calendar1 = Calendar.getInstance();//静态方法，直接使用即可
System.out.println(instance);   //输出很长
calendar1.set(Calendar.DAY_OF_MONTH,14);    //更改日期的号
calendar1.add(Calendar.HOUR_OF_DAY,1);
System.out.println(calendar1.getTime().toLocaleString());

int actualMaximum = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);//365
int actualMinimum = calendar.getActualMinimum(Calendar.DAY_OF_YEAR);//1

SimpleDateFormat

SimpleDateFormat sdf = new SimpleDateFormat("yyyy--MM--dd");
String str = sdf.format(new Date());
System.out.println(str);

Date date = sdf.parse("2022--10--23");
System.out.println(date);

System

System.arraycopy(src,start,dest,start,length);
System.currentTimeMillis();
System.gc();
System.exit(0);