Java

1.Hello World

1
2
3
4
5
public class Hello{
	public static void main(String[] args){
		System.out.print("Hello,World!");
	}
}

image-20250304205733394

编译javac java文件 生成class文件

运行class文件， java class文件

注意事项：

  • Java是大小写敏感
  • 尽可能使用英文
  • 文件名和类名必须保证一致，并且首字母大写

2.基础

1.注释

Java中注释分为三种：

  1. 单行注释
  2. 多行注释
  3. 文档注释

单行注释与多行注释为// 与/**/ 与c语言一样

文档注释：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class HelloWorld {
    public static void main(String[] args) {
        //单行注释：只能注释一行
        //输出一个hello，world！
        System.out.println("Hello World!");
        //JavaDoc：文档注释 /** */
        /**
         * @Description HelloWrold
         * @Author 。。
         */
    }
}

2.标识符、关键字

Java所有的组成部分都需要名字。类名、变量名以及方法名都称为标识符

  • 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始
  • 首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名
  • 标识符是大小写敏感的

3.数据类型

基本类型：

image-20250306232805331

引用类型：类，接口，数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Demo {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        int num1 = 10;//最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;//Long类型要在数字后面加个L
        //小数：浮点数
        float num5 = 50.1F; //float类型要在数字后面加个F
        double num6 = 3.141592653589793238462643;
        //字符
        char name = '国';
        //字符串,String不是关键字，是一个类
        //String name = "张三";
        //布尔值：是非
        boolean flag = true;
        //boolean flag = false;
    }
}
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
36
37
38
39
public class Demo {
    public static void main(String[] args) {
        //整数拓展：二进制0b 八进制0 十六进制0x
        int i = 10;
        int i2 = 010;   //八进制0
        int i3 = 0x10;  //十六进制0x
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        //所有的字符本质还是数字
        //编码 Unicode
        char c1 = 'A';
        char c2 = '中';
        char c3 = '\u0061';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        System.out.println(c3);
        //转义字符
        // \t 制表符
        // \n 换行
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");
    }
}

运行结果
10
8
16
A
65
中
20013
a
Hello	World
Hello
World

4.类型转换

  • 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

    1
    2
    低------------------------------------->高
    byte,short,char->int->long->float->double

  • 运算中，不同类型的数据先转化为同一类型，然后进行运算

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 class HelloWorld {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;//内存溢出
        //强制转换 (类型)变量名 高--低
        //自动转换 低--高
        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.在把高容量转换到低容量的时候，强制转换
        4.转换的时候可能出现内存溢出，或者精度问题
         */
        System.out.println((int)23.7);
        System.out.println((int)-45.89f);

        char c = 'a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char)d);

        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;//-1474836480，计算的时候溢出了
        long total2 = money*years;//默认是int，转换之前就已经存在问题
        long total3 = money*((long)years);//先把一个数转换为long
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
    }
}

5.变量、常量、定义域

变量：

  • Java是一种强类型语言，每个变量都必须声明其类型

  • Java变量是程序中最基础的存储单元，其要素包括变量名，变量类型和作用域

    1
    2
    type varName [=value] [{,varName[=value]}];
    //数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类变量

注意事项：

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
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
public class Main {
    //类变量 static
    static double salary = 2500;
    //属性：变量
    //实例变量：从属于对象；
    //布尔值：默认是false
    String name;
    int age;
    //main 方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);

        //变量类型 变量名字=new Main（）
        Main demo = new Main();
        System.out.println(demo.age);
        System.out.println(demo.name);

        //类变量 static
        System.out.println(demo.salary);

        //其他方法

    }
}

运行结果：

1
2
3
4
10
0
null
2500.0

常量

  • 常量：初始化后不能再改变值，不会变动的值

  • 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

    1
    2
    final 常量名=值;
    final double PI = 3.14;

  • 常量名一般使用大写字符

1
2
3
4
5
6
7
public class Demo {
    //修饰符，不存在先后顺序
    static final double PI = 3.14;//final static double也可
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词以外，后面的单词首字母大写
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man，GoodMan
  • 方法名：首字母小写和驼峰原则：run()，runRun()

6.基本运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package operater;

public class demo2 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl + D :复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 30;
        System.out.println(a + b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);
    }
}
运行结果：
30
-10
200
0.5
1
2
3
4
5
6
7
8
9
10
11
package operator;
public class Demo {
    public static void main(String[] args) {
        long a = 123123123123123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        System.out.println(a+b+c+d);//有long则运算结果为long
        System.out.println(b+c+d);//无long则运算结果为int
        System.out.println(c+d);//即使无int运算结果仍为int
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package operator;
public class Demo {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误 布尔值
        int a = 10;
        int b = 20;
        int c = 21;
        System.out.println(c%a);
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
    }
}
运行结果：
1
false
true
false
true

7.自增自减运算符、math类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package operator;
public class Demo {
    public static void main(String[] args) {
        //++ -- 自增，自减 一元运算符
        int a = 3;
        int b = a++;
        System.out.println(a);
        System.out.println(b);
        int c = ++a;
        System.out.println(a);
        System.out.println(c);
        //幂运算 2^3 2*2*2 = 8
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}
运行结果：
4
3
5
5
8.0

8.逻辑运算符、位运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package operator;
public class Demo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(b&&a));
        System.out.println("a || b:"+(a||b));
        System.out.println("!(a && b):"+!(a&&b));
        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
        System.out.println(2<<3);
    }
}
运行结果：
a && b:false
a || b:true
!(a && b):true
false
5
16

9.三元运算符及小结

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
package operator;
public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a+=b;
        System.out.println(a);
        a-=b;
        System.out.println(a);
        //字符串连接符 + ,String
        System.out.println(""+a+b);//前面是字符串最后结果为字符串
        System.out.println(a+b+"");//前面是数据最后结果是数据
        //x ? y : z
        int score = 50;
        String type = score <60 ?"不及格":"及格";
        System.out.println(type);
    }
}

运行结果：
30
10
1020
30
不及格

10.包机制

  • 为了更好组合类，Java提供了包机制，用于区别类名的命名空间

  • 包语句的语法格式为：

    1
    package pkg1[. pkg2[. pkg3...]];

  • 一般利用公司域名倒置作为包名

  • 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能

    1
    import package1[.package2...].(classname|*);
1
2
3
package com.zhang.operator;
//导入这个包下所有的类
import com.zhang.misc.*;

11.JavaDoc生成文档

  • JavaDoc命令是用来生成自己API文档的
  • 参数信息
    • @author 作者名
    • @version 版本号
    • @since 指明需要最早使用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws异常抛出情况
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package cccc;
/**
 * @author zhangsan
 * @version 1.0
 * @since 1.8
 */
public class demo4 {
    String name;
    /**
     * @author cccccc
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name)throws Exception{
        return name;
    }
}

在当前java文件夹下打开cmd，输入：

1
javadoc -encoding UTF-8 -charset UTF-8 demo4.java

3.面向对象

1.方法的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package oop;

import java.util.Scanner;

public class demo1 {

    //静态方法 static
    //和类一起加载 即当demo1加载时也加载

    //非静态方法
    //在类实例化后才存在

    public static void main(String[] args) {
        //实例化这个类 new
        //对象类型 对象名 = 对象值
        Student student = new Student();
        student.say();
    }
}

1
2
3
4
5
6
7
8
9
10
11
package oop;

//学生类
public class Student {

    //方法
    public void say(){
        System.out.println("Hello World");
    }
}

2.继承

子类继承父类，使用extends

1
2
public class Student extends Person{
}

Ctrl+H显示类的树（继承关系）

在JAVA中所有类都默认直接或间接继承Object类

3.Super

this指向当前对象自己 super指向当前对象自己的父类

注意点：

  • super的调用父类的构造方法必须在构造方法的第一个
  • super必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法

4.方法重写

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

需要有继承关系，子类重写父类的方法

  • 方法名必须相同

  • 参数列表必须相同

  • 修饰符：范围可以扩大但不能缩小：public>protect>default>privatte

  • 抛出的异常：范围可以缩小但不能扩大：ClassNotFoundException–>Exceptionn(大)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class B{
    public void test(){
        System.out.println("B->test()");;
    }
}

public class A extends B{
    //Override 重写
    @Override//注解：有功能的注释；
    public void test(){
        System.out.println("A->test()");;
    }
}

//静态方法：方法的调用只和左边，定义的数据类型有关
//非静态方法：重写
A a=new A();
a.test();//A

B b=new A();
b.test();//B

5.多态

多态存在条件：

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

多态是方法的多态，属性没有多态性

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
36
父类类型 变量名 = new 子类类型（）；
    Person a = new Student();


public class demo04 {
    public static void main(String[] args) {
        People p=new Stu();
        p.eat();
        //调用特有的方法
        Stu s=(Stu)p;
        s.study();
        //((Stu) p).study();
    }
}
class People{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Stu extends People{
    @Override
    public void eat(){
        System.out.println("吃水煮肉片");
    }
    public void study(){
        System.out.println("好好学习");
    }
}
class Teachers extends People{
    @Override
    public void eat(){
        System.out.println("吃樱桃");
    }
    public void teach(){
        System.out.println("认真授课");
    }

6.instanceof关键字

用来判断某个对象是否属于某种数据类型

返回类型为布尔类型

1
2
3
4
5
6
7
8
Fu f1=new Zi();
Fu f2=new Son();
if(f1 instanceof Zi){
    System.out.println("f1是Zi的类型");
}
else{
    System.out.println("f1是Son的类型");
}

7.抽象类

abstract只有方法名字，没有方法实现

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

抽象类中可以写普通方法，抽象方法必须在抽象类中

8.接口

在JAVA中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口声明：

1
2
3
4
public interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

接口实现：

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

1
public class xxx implements 接口名称[, 其他接口名称, 其他接口名称..., ...]

9.异常处理

java异常指在程序运行时可能出现的一些错误，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，中断了正在执行的程序的正常指令流。

Java异常类的层次结构图

image-20250325224354312

Java所有异常类都是 Throwable的子类。它包括Java异常处理的两个重要子类：Error和Exception.

Error：Error及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，是程序无法处理的错误。

Exception：可以通过捕捉处理使程序继续执行，是程序自身可以处理的异常，也称为非致命性异常类

异常处理机制分为：抛出异常，捕捉异常

抛出异常：

当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

捕捉异常：

在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。

异常处理的五个关键字：try、catch、finally、throw、throws

1
2
3
4
5
6
7
8
try{//try检测区域

}catch(){//catch捕获异常
    
}finally{//处理善后工作
    
}
//先执行try 块中的代码，如果正常运行没有发生异常则执行完后执行finally 代码块中的代码；如若在try 中发生异常且被catch 捕捉到则执行catch 中的代码块，然后执行finally 块中的代码

抛出异常：

throws：

通常被用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔。throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

throw：

通常用在方法体中或者用来抛出用户自定义异常，并且抛出一个异常对象。程序在执行到throw语句时立即停止，如果要捕捉throw抛出的异常，则必须使用try-catch语句块或者try-catch-finally语句。