java零基础从入门到精通-超详细基础语法知识点总结笔记

JAVA知识点总结

一、DOS命令（了解）

DOS：磁盘操作系统(disk operation system)

DOS命令：通过命令操作电脑的指令集合

1. 打开命令行
   • win+R输入cmd回车（进入用户家目录）
   • 文件夹地址栏输cmd回车（进入文件夹目录）
2. 切换盘符：盘符:（回车）
3. 切换路径 cd（change directory）
   • cd …（退回上一层）
   • cd 文件夹名（打开当前路径打开文件夹）
   • cd ./文件夹名（同上）
   • cd 绝对路径（如C:…，涉及相对路径）
4. 查看当前路径：dir（回车）
5. 新建文件夹：md 文件夹名（回车）
6. 写入文件内容
   • echo 内容>文件（文件不存在则自动创建，会覆盖原内容）
   • echo 内容>>文件（追加内容）
7. 删除文件：del 文件（回车）
8. 移除文件夹：remove 文件夹（回车）
9. 清屏：cls（回车）
10. 查IP：ipconfig（回车）

二、第一个Java程序

1. 编写软件：记事本、eclipse、Intellij Idea
2. HelloWorld程序（文件：HelloWorld.java）

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

3. 运行（地址栏输入cmd回车）
   • javac HelloWorld.java（编译java文件，生成字节码文件HelloWorld.class）
   • java HelloWorld（运行，不要加后缀）
4. 注意事项
   • 文件名和文件内class后名称一致
   • 注意大小写，仅Syetem、String首字母大写
   • 所有标号均为英文标点
   • 语句后均要有分号

三、创建包

包（package）：目的是将不同功能分隔开，包名要求为公司反域名（如com.名称）

四、基本语法要求

1. 基本结构

// 类，一个类一个功能
public class 文件名 {
    public static void main(String[] args){   // 主方法，是程序唯一出口
        
    }
}

2. 语法要求

   • 命名要求

     • 项目名小写

     • 包名：公司反域名小写

     • 类名：大写驼峰，见名知意

       ​ a. 首字母大写，多个单词时每个首字母均大写；

       ​ b. 不使用特殊符号，阿里规范不建议用_和$；

       ​ c. 数字不能开头

   • 格式要求：大括号前不换行后后换行，每个{}都要注意缩进

   • 注释要求

     • 单行注释：

       //单行注释
       

     • 多行注释：

       /* 
       注释
       */
       

     • 文档注释：

       /**
       *文档注释
       *
       *@标签 描述(javadoc标签，常用的有@author、@param等等)
       */
       

五、输出语句

1. System.out.print()

   作用：将()内内容输出到控制台

   语法：

   • 数字可直接写，
   • 其他字符加""
   • 无ln不换行
   • 括号内不能为空
   • 可用"\r\n"实现换行

2. System.out.println() :

   作用：输出完换行，括号内为空则仅换行

补录1：Intelij Idea 快捷键介绍

• Ctrl+d 重复一行
• Ctrl+y 删除一行
• Ctrl+alt+↑ 移动一行

六、常用工具介绍

1. 截图贴图：Snipaste
2. 视频播放器：PotPlayer
3. AI工具
   • 小阿里-通义千问：https://tongyi.aliyun.com/qianwen（代码相关）
   • 百度-文心一言：https://yiyan.baidu.com（文章相关）
   • Deep Seek：https://chat.deepseek.com
   • Chat GPT
4. 笔记
   • 优快云（白域）
   • 语雀（私域）
   • 思维导图：xmind（软件）、Processon（在线，www.processon.com diagrams）
5. typora工具

七、变量

1. 声明：数据类型 变量名; 或 数据类型 变量名 = 值;
2. 赋值：变量 = 值;
3. 变量名：小驼峰（首字母小写，多个单词时其他单词首字母大写）
4. 数据类型
   • 小整型：byte、short、int、long
   • 浮点型：float、double
   • 字符型：char
   • 布尔型：boolean
   • 引用数据类型：数组、类、接口

八、整型

• byte（字节）：1byte=8 bit，总共能代表256个数[-128~127]（一般用于传输数据）
• short（短整型）：1 short=2 byte，总共能代表65536个数[-32768~32767]（很少用）
• int（整型）：1 int=4 byte，[-2147483648~2147483647]（默认用）
• long（长整型）：1 long=8 byte（int不够时使用）

九、浮点型

• float（单精度）：32 bit，有效位数8位（一般不用，使用时后面加f/F，如表示钱时）

• double（双精度）：64 bit，有效位数16位，后面可加d/D（默认为d，常用）

十、字符型

char代表单个字符（16位），只能使用单引号，且内只能有且仅有一个字符。特殊的是，char可以被0~65535数字赋值（不用单引号）

十一、布尔型

boolean主要用于判断，只有两个值：true、false

十二、数据类型的转换

1. 小转大（默认进行）
   • 整型：byte→short→int→long
   • 浮点型：float→double
   • 整→浮、整→char、char→int/long
2. 大转小（默认不允许，可强制转换）

           char
            ↓
   byte——→short——→int——→long
                      ↓
                 float→double
   

   箭头方向默认进行，反之须强转

十三、String类型（字符串）

使用双引号，内可包含任意个字符，可为空字符串，拼接内容使用‘+’连接

十四、运算符

1. 赋值运算：=、+=、-=等
2. 算术运算：+、-、*、/、%、++、–
3. 关系运算：>、<、>=、<=、==、!=（运算结果为true/false）
4. 逻辑运算：&（与）、|（或）、!（非）（运算结果为布尔值）
   • 短路操作：&&（前面错，后面不执行）、||（前面对，后面不执行）
5. 三目运算（三元运算）：布尔表达式 ? true时执行 : false时执行

十五、Scanner键盘输入

Scanner是JDK提供的工具，专用于键盘输入

用于从外部输入数据，进入程序后再进行运算

步骤如下：

1. 导包：import java.util.Scanner;
2. 创建对象：Scanner 变量名1 = new Scanner(System.in);
3. 调用方法完成输入并接收数据

   数据类型 变量名2 = scanner.方法();
   // 方法包括next()、nextLine()（均输入字符串）、nextInt()（输入整数）、nextDouble()（输入小数）
   

4. 关闭：Scanner.close()（可关可不关）

十六、流程控制语句

1. 分支语句
   • 单分支：if(布尔表达式){ …; }
   • 双分支：if(布尔表达式){ …; } else { …; }
   • 多分支：if(布尔表达式){ …; } else if(布尔表达式){ …; } else { …; }
2. 选择语句

   switch(变量/值) {
       case 值1: ...; break;
       case 值2: ...; break;
       ...
       default: ...;
   }
   

3. 循环语句
   • while循环（先判断后执行）：while(布尔表达式){ …; }
   • do-while（先执行后判断）：do{ …; } while(布尔表达式);
   • for循环：for(初始值;条件;迭代){ …; }
4. 流程控制关键字：continue;、break;

十七、方法

1. 语法

   public static 返回值类型 方法名(数据类型 参数名) { // 定义参数（小驼峰）
       return 返回值; // void仅return;
   }
   方法名(参数); // 使用方法并传参
   

2. 方法返回return
   • return是结束方法的，后面不能有代码
   • return可以只用于结束方法，不返回数据
3. 方法的递归调用
   • 方法执行会进栈，执行完弹栈消失
   • 方法循环调用会形成闭环，导致内存溢出

十八、数组

1. 介绍

   • 数组是数据的组合，存储多个数据
   • 数组一旦创建，长度和类型固定不变
   • 数组没有方法，只有一个属性length（arr.length表示数组长度）

2. 语法

   • 声明：数据类型[] 数组名;

   • 创建数组（初始化，可合并写）

     • 数组名 = new 数据类型[长度];

       注：数组初始创建后内部有默认值：

       整：0、浮：0.0、字符：’ '(空格)、引用数据类型(数组，类，接口，String字符串)：null(空)

     • 数组名 = new 数据类型[]{值1,值2,…} （无需写长度，自动计算）

   • 赋值和调用：arr[下标] = 值；变量 = arr[下标]

3. 引用数据类型

   • Java数据类型：
     • 基本数据类型
     • 引用数据类型（将对象地址值传递使用）
   • JVM内存五大区域：
     1. 栈（新进后出的队列）
     2. 堆（凡是new的对象都会进堆）
     3. 被本地方法区
     4. 本地方法栈
     5. 程序计数器

4. 数组排序

   • 冒泡排序

   /*
   * 相邻两个依次比较，大的放后面
   */
   for (int i = 0; i < arr.length - 1; i++) {
       for (int j = 0; j < arr.length - i - 1; j++) {
           if (arr[j] > arr[j + 1]) {
               int temp = arr[j];
               arr[j] = arr[j + 1];
               arr[j + 1] = temp;
           }
       }
   }
   

   • 选择排序

   /*
   * 将数据分为两个区间：已排序，未排序
   * 1. 设第一个数为最小，然后依次往后找更小的，记录下标，第一个数与最小的数交换位置
   * 2. 将最小的数放在前面并归为已排序区间，在未排序区间内多次重复上面操作至未排序区间为空
   * @param arr 未排序的纯数字数组
   */
   for (int i = 0; i < arr.length; i++) {
       int minIndex = i;
       for (int j = i; j < arr.length; j++) {
           if (arr[j] < arr[minIndex]) {
               minIndex = j;
           }
       }
       int temp = arr[i];
       arr[i] = arr[minIndex];
       arr[minIndex] = temp;
   }
   

   十大排序算法：冒泡排序、选择排序、插入排序、快速排序、堆排序、希尔排序、归并排序、桶排序、计数排序、基排序

5. 二分查找算法（折半查找）（前提：数组是有序数组）

   public static int research(int[] arr, int e) {
       int left = 0; // 左边界下标
       int right = arr.length - 1; // 右边界下标
       int mid = (left + right) / 2;
       while (left <= right) {
           if (e > arr[mid]) {
               left = mid + 1; // 要找元素在右边界，缩左边界
           } else if (e < arr[mid]) {
               right = mid - 1; // 要找元素在左边界，缩右边界
           } else {
               return mid;
           }
           mid = (left + right) / 2;
       }
       return -1; // 数组中不存在该元素
   }
   

6. 数组拷贝

   • 手动拷贝：for循环逐个赋值到新数组内

     for(int i = 0;i < arr;i++){
         newArr[i] = arr[i];
     }
     

   • System.arraycopy(源数组, 开始下标, 目标数组, 拷贝到的下标, 拷贝长度)

   • Arrays.copyOf()：从原始数组拷贝指定个数到新数组中

     int[] newArr = Arrays.copyOf(拷贝数组, 新数组长度) 	//新数组自动创建
     

7. 数组扩容（一旦建立数组长度固定不变，扩容即创建2倍长度新数组并拷贝元素到新数组）

   public static int[] changeSize(int[] arr) {
       int[] newArr = Arrays.copyOf(arr, arr.length * 2);
       return newArr;
   }
   

8. Arrays数组工具类

   • Arrays.copyOf(arr, length)：拷贝数组
   • Arrays.sort(arr)：数组排序（从小到大，无返回值）
   • Arrays.toString(arr)：将数组转为字符串（如"[1, 2, 3]"）
   • Arrays.binarySearch(arr, 查找的元素)：二分查找，返回下标

十九、面向对象编程（OOP）

1. 介绍：Java是面向对象编程（针对或以对象为导向的编程），区别于C的面向过程（针对逻辑过程细节）

2. 概念

   • 类：具有相同特点(描述类特征)及动作(方法)的多个对象的集合
   • 对象：类的具体化、实例化，是由类创造出的具体表现

3. 第一个类

   public class People {	//类名要见名知意，使用驼峰原则
       String name; // 类属性
       int age;
       public void eat(String food) { // 类方法
           System.out.println("吃" + food);
       }
   }
   

4. 对象

   • 创建对象：类名 对象名 = new 类名()

   • 使用对象属性：赋值（对象名.属性 = 值）、使用（对象名.属性名）

   • 使用对象方法：对象名.方法名(参数)

   • 内存关系：

     1. 方法执行进栈；
     2. 凡是new的对象都会进堆；
     3. new类名时在堆开辟空间、分配地址、初始化对象属性

   • 多引用指向一个对象：多个引用指向同一对象地址，修改一个引用的属性会影响其他引用

     /*
     * @param People People类详见3.
     */
     People people = new People();
     People human = people;
     People ren = people;
     people.name = "Mike";
     people.age = "18";
     System.out.println("我是" + human.name + "今年" + ren.age + "岁")；
     //运行结果：我是MIke今年18岁[换行]
     

5. 成员变量和局部变量

   	成员变量	局部变量
   位置	类中方法外	方法内
   使用范围	类中所有方法都可使用	只能在方法内使用
   初始值	创建对象时会默认赋值	必须主动给初始值
   内存位置	堆中	栈中
   生存周期	new时出现，被垃圾回收时消失	进栈时出现，方法弹栈时消失

   • 注：成员变量和局部变量可重名，方法默认使用局部变量（就近原则），可用this.变量名调用成员变量

6. 构造方法（构造函数、构造器constructor）

   • 作用：创建对象及初始化属性，每个类默认有一个无参构造

   • 语法：不写static，无返回值（不用写返回值类型和void），名字与类名相同

   • 示例

     public class A {
         int num;
         String name;
         public A() { // 无参构造
             System.out.println("我是" + name);//创造对象时执行
             //设置默认值
             num = 0;
             name = "A";
         }
         public A(int num, String name) { // 有参构造（写有参构造时，必须先写无参构造）
             //this.指的是成员变量，即开头的int和name
             this.num = num;
             this.name = name;
         }
     }
     // 使用：A a1 = new A(); //该无参构造运行结果：我是A
     //      A a2 = new A(5, "B"); //该有参构造运行结果：我是B
     

7. 重载(Overload)

   • 定义：同一个类中，方法名相同，参数列表不同的多个方法

   • 作用：使一个方法传入不同参数都能执行，自动根据参数执行对应方法

   • 示例：People类中定义多个不同参数的构造方法

     public class People{
         int age;
         String name;
         public People(){} //无参数时 age=0，name=null
         public People(int age){ //只有age参数时
             this.age = age;
         }
         public People(String name){ //只有name参数时
             this.name = name;
         }
         public People(int age, String name){
             this.age = age; //先age后name时
             this.name = name;
         }
         public People(String name, int age){
             this.age = age; //先name后age
             this.name = name;
         }
     }
     

8. 对象创建的过程（记住）：new调用构造方法创建对象时，先初始化类的属性，再执行构造方法内的代码

9. 面向对象编程核心特点

   1. 封装

   • 定义：将复杂功能算法封装，对外暴露可访问代码，无需关注内部细节，集成性好

   • 类型：

     1. 方法的封装

     2. 类封装

        • private类属性私有（只能在类中使用）

        • 提供set和get方法，命名为：set/get + 属性首字母大写

   • 示例

     public class People {
         private int age;
         String name;
         public void setAge(int age) {
             if (age > 0 && age < 150) {
                 this.age = age;
             } else {
                 System.out.println("age out of limited");
             }
         }
         public int getAge() {
             return age;
         }
     }
     

   2.继承

   1. 介绍：

      • 父类的属性和方法提供给子类使用
      • 减少重复代码，将多个类重复的属性和方法抽取到父类中
      • 继承是多态的前提

   2. 语法：public class A extends B {}（A为子类，B为父类）

   3. 特征：

      • Java只能单继承，子类只能继承一个父类
      • 继承可多层次继承，即子可以承父，子子可以承子

   4. 继承的属性和方法：

      • 子类不能使用父类私有属性和方法；
      • 子类可有与父类相同的属性（默认用自己的，就近调用）；
      • 子类可有与父类相同的方法（即方法重写，就近调用）

   5. 重写语法要求：

      • 访问修饰符范围不小于父类；
      • 返回值类型、方法名、参数列表相同；
      • 方法体内容不同

   6. 子类对象创建过程：先创建父类对象，再创建子类对象；new调用构造时先父类后子类，先属性后构造；子类构造方法第一行隐藏super()（调用父类构造）

   7. this和super

   操作	this（当前对象）	super（父类对象）
   调用方法	this.方法1();	super.方法1();
   调用属性	this.属性	super.属性
   调用构造（只能写在构造方法第一行）	this(); this(参数);	super();super(参数);

   注：每个之类构造方法默认第一行有 super();

   3. 多态

      1. 实现条件：

         • 继承
         • 重写
         • 向上转型（父类引用指向子类）

      2. 应用场景：

         • 方法参数设为父类类型，调用时传入子类类型，运行出对应子类效果；
         • 方法返回值类型为父类，返回子类对象

      3. 向上转型：（父类引用只能调用父类有的属性和方法）

      Father father = new Son();
      father.父类方法();//只能调用父类有的属性和方法
      

      4. 向下转型：（可调用子类特有方法和父类方法）

      Father father = new Son();//先向上转型
      Son son = (Son) father;//再向下转型
      son.子类方法();//调用子类特有方法
      son.父类方法();//调用父类特有方法
      

   4. 抽象

      1. 抽象方法：

         • 无方法体

         • 被abstract修饰

         • 必须在抽象类中

      2. 抽象类

         • 被abstract修饰

         • 可无抽象方法

         • 有构造方法但不能new创建对象

      3. abstract不能修饰属性

      4. 子类继承抽象父类：

         • 构造子类时子类默认调用父类中的抽象方法，
         • 继承的前提是：要么子类为抽象类，要么重写父类所有抽象方法

      5. 抽象类可用作多态，虽不能创建父类对象，但可用作父类引用指向子类对象

      6. 示例

         public abstract class Animal {
             public abstract void eat();
         }
         public class Dog extends Animal {
             public void eat() { ... }
         }
         

   5. 接口

      • 介绍：

        • 基础数据类型：四类八种
        • 引用数据类型：数组、类、接口
        • 注：接口不是类，标志为interface，是一种java文件，新建接口时不选class选择interface

      • 特点

        • 属性全为静态常量，默认被public static final修饰
        • 方法全为抽象的，默认被public abstract修饰
        • 接口无构造方法，不能被new
        • 接口的存在是为了被子类实现（implements），子类可同时实现多接口
        • 接口可继承接口，且允许多继承
        • 注：题目中实现是继承，虚线时实现接口

      • 案例

        public interface USB {
            double volume = 100;
            void send();
        }
        public class A extends father_class implements USB, I2, I3 {
            public void send() { ... }
        }
        

10. 访问修饰符

    • 介绍
      • 访问：即 可调用
      • 修饰符：即 限制可调用范围
    • 作用：主要用于修饰属性和方法的访问范围

    修饰符	当前类	当前包其他类	其他包子类	其他包非子类
    public	√	√	√	√
    protected	√	√	√	×
    缺省(默认)	√	√	×	×
    private	√	×	×	×

    • 访问范围大小：public > protected > 缺省(包) > private
    • protected在其他包子类中，子类对象可调用父类保护属性，父类不能调用自己的保护属性

11. final修饰符

    • 修饰对象：
      • 类（public final class …）
      • 属性/变量（final int …）
      • 方法（public final void …）
    • 作用
      • 修饰类：不能被继承（无子类）
      • 修饰方法：不能被重写
      • 修饰变量：变为常量，不可改变
    • 命名规范：
      • 变量用小写驼峰；
      • 常量全部大写，多单词用_隔开

12. Static修饰符

    • 修饰对象：类（静态内部类、静态代码块）、方法、属性/变量
    • 语法说明：
      • 被static修饰的方法和属性随类加载初始化，不在堆中；
      • 未创建对象也可调用静态属性和方法；
      • 静态属性和方法不在堆和栈中，而在方法区中，无论创建多少对象仅此一个
    • 使用总结
      • 静态属性和方法建议用类名调用
      • 静态方法内可直接调用其他静态方法和属性
      • 静态方法内不能直接调用非静态方法和属性，需创建对象通过对象调用