Java基础知识和语法学习（两万字笔记！！！）

已于 2023-08-20 17:01:32 修改
阅读量247 收藏 3
点赞数 2
分类专栏： Java学习 文章标签： java 学习 笔记 intellij-idea
于 2023-08-20 01:01:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62881487/article/details/132232876
版权

Java学习目录

一、运行首个案例

1.1 HelloWorld代码块

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

1.2 注意问题

 1. 第三行后面是英文的分号。
 2. " System "中的S必须大写。
 3. println()其实调用了print()再调用newLine()来实现换行。改成print()没有换行功能。

二、注释

2.1 注释概述

 1. 注释是在指定位置添加的说明性信息。
 2. 注释不参与程序运行，仅起到说明性作用。

2.2 注释分类

 1. 单行注释

  • 格式：//注释信息

 2. 多行注释

  • 格式：/*注释信息*/

 3. 文档注释（很少用到，不做讲解）

  • 格式：/**注释信息*/

2.3 为首个案例添加注释

/*
 Java中最基本的组成单位是类
 类的基本格式：public class 类名 {

 }
*/
public class HelloWorld {
    //这是main方法，它是程序的入口方法，程序的执行是从这里开始的
    public static void main(String[] args){
        //这是输出语句
        System.out.println("HelloWorld"); //System类是一些与系统有关的属性和方法的集合
    }
}

三、关键字

3.1 关键字特点

 1. 关键字的字母全部小写。
 2. 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观。
 3. 关键字和保留字均不能用作变量名、方法名、类名、包名和参数。

3.2 常用的关键字

 Java中常用的关键字有五十多个，如：

  • 具体的保留字：goto、const
  • 访问修饰符：public、protected、private
  • 类、接口、抽象类：class、interface、abstract——定义，extends——继承类，implements——实现接口，new——新建一个对象，super——调用父类方法，this——指代当前对象

四、常量

4.1 常量概述

 常量：在程序运行过程中，其值不可以发生改变的量。

4.2 常量分类

常量类型说明举例
字符串常量用英文双引号括起来的内容" HelloWorld “，” Java学习 "
整数常量不带小数的数字666，-88
小数常量带小数的数字13.14，-5.21
字符常量用英文单引号括起来的内容’ A ‘，’ 0 ‘，’ 我 ’
布尔常量布尔值，表示真假只有两个值：true，false
空常量一个特殊的值，空值值是：null

 注意事项：空常量是不能直接输出的 !

五、数据类型

5.1 类型分类

 Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小是不一样的。
 数据类型分为基本数据类型和引用数据类型：

  • 基本数据类型：①数值型：整数（byte、int、short、long）、浮点数（float、double）、字符（char）。 ②非数值型：布尔（boolean）。
  • 引用数据类型：类（class）、接口（interface）、数组（[ ]）。

5.2 数据类型内存占用

关键字内存占用
byte1B
short2B
int4B
long8B
float4B
double8B
char2B
boolean1B

 注意事项：给一个整数，默认int类型；给一个浮点数，默认double类型。

六、变量

6.1 变量概述

 变量：在程序运行过程中，其值可以发生改变的量。从本质上讲，变量是内存中的一小块区域。

6.2 变量定义

 1. 变量组成：变量名、数据类型、变量值。
 2. 格式：数据类型 变量名=变量值; 例如：int a=10;

6.3 变量的使用

 1.取值：

  • 取值格式：变量名
  • 范例：a

 2. 修改值：

  • 修改值格式：变量名=变量值;
  • 范例：a=20;
public class Demo {
    public static void main(String[] args){
        //定义变量
        int a=10;
        //输出变量
        System.out.println(a);
        //修改变量
        a=20;
        //输出变量
        System.out.println(a);
    }
}

6.4 变量使用的注意事项

 1. 变量名不能重复。
 2. 定义变量时一定要给个初始值，未赋值的变量不能直接使用。
 3. 定义long类型的变量时，为了防止整数过大，后面要加L。
 4. 定义float类型的变量时，为了防止类型不兼容，后面要加F。

public class Demo {
    public static void main(String[] args){
        //加L，因为默认是int
        long a=10000000000L;
        System.out.println(a);
        //加F，因为默认是double
        float b=13.14F;
        System.out.println(b);
    }
}

七、标识符

7.1 标识符概述

 1. 标识符：就是给类、方法、变量等起名字的符号。
 2. 标识符定义规则：

  • 由数字、字母、下划线（_）和美元符（$）组成。
  • 不能以数字开头。 例如：2b
  • 不能是关键字。 例如：class
  • 区分大小写。

7.2 常见命名约定

 1. 小驼峰命名法：适用于定义方法和变量。

  • 标识符是一个单词的时候，首字母小写。例如：name
  • 标识符是多个单词组成的时候，第一个单词小写，其它单词首字母大写。例如：firstName

 2. 大驼峰命名法：适用于定义类。

  • 标识符是一个单词的时候，首字母大写。例如：Student
  • 标识符是多个单词组成的时候，每个单词首字母大写。例如：GoodStudent

八、类型转换

8.1 自动类型转换

 1. 把一个表示数据范围小的数值或变量赋值给另一个表示数据范围大的变量。
 2. 转换规则图：
在这里插入图片描述

8.2 强制类型转换

 1. 把一个表示数据范围大的数值或变量赋值给另一个表示数据范围小的变量。
 2. 格式：目标数值类型 变量名=（目标数值类型）变量或值; 例如：int k=(int)88.88;

8.3 代码举例

public class Demo {
    public static void main(String[] args){
        //自动类型转换
        double d=10;
        System.out.println(d); //输出10.0

        //强制类型转换
        int k=(int)88.88;
        System.out.println(k); //输出88
        
        //这些是可以的
        byte b=8;
        short a=b;
        int i=b;

        //这是不可以的，会报错
        char c=b;
    }
}

九、运算符

9.1 算术运算符

 1. 算术运算符表格：

符号作用
+加
-减
×乘
/除
%取余

 2. 注意事项： 两个数做除法，/取结果的商，%取结果的余数。整数操作只能得到整数，要想得到小数，必须有浮点数参加运算。

9.2 “＋”操作

 1. 字符的＋操作：

  • 'A’→65，A-Z是连续的。
  • 'a’→97，a-z是连续的。
  • '0’→48，0-9是连续的。

 2. 算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。等级顺序：byte，short，char→ int → long → float → double

public class Demo {
    public static void main(String[] args){
        int i=10;
        char a='A'; //'A'的值是65
        System.out.println(i+a); //输出75
        
        //这是不可以的，int不能降为char
        char j=i+a;
        //char类型会自动提升为int类型
        int k=i+a;
    }
}

 3. 字符串的＋操作：

  • 当“＋” 操作中出现字符串时，这个“＋” 是字符串连接符，而不是算术运算。
  • 在“＋” 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“＋” 操作时，从左到右逐个进行。
public class Demo {
    public static void main(String[] args){
        System.out.println("Good"+"Student");//输出GoodStudent
        System.out.println("Good"+666);      //输出Good666
        System.out.println(1+20+"Good");     //输出21Good
    }
}

9.3 赋值运算符

 1. 赋值运算符表格：

符号作用说明
=赋值a=10，将10赋值给变量a
+=加后赋值a+=b，将a+b的值赋给a
-=减后赋值a-=b，将a-b的值赋给a
*=乘后赋值a*=b，将a×b的值赋给a
/=除后赋值a/=b，将a÷b的值赋给a
%=取余后赋值a%=b，将a÷b的余数赋给a

 2. 注意事项： 扩展运算符隐含了强制类型转换。

public class Demo {
    public static void main(String[] args){
        short a=20;
        a+=20; //隐含了强制类型转换
        a=(short)(a+20); //a=a+20; 这样会报错的
        System.out.println(a); //输出结果为40
    }
}

9.4 自增自减运算符

 1. 自增自减运算符表格：

符号作用说明
++自增变量的值加1
- -自减变量的值减1

 2. 注意事项：

  • ++和- -既可以放在变量的后边，也可以放在变量的前边。
  • 单独使用的时候，++和- -无论放在变量的前边还是后边，结果是一样的。
  • 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者- -；参与操作的时候，如果放在变量的前边，先拿变量做++或者- -，后拿变量参与操作。
public class Demo {
    public static void main(String[] args){
        int i1=10;
        int j1=i1++;
        int i2=10;
        int j2=++i2;
        System.out.println(j1); //输出10
        System.out.println(i1); //输出11
        System.out.println(j2); //输出11
        System.out.println(i2); //输出11
    }
}

9.5 关系运算符

 1. 关系运算符表格：

符号说明
==a==b，判断a和b的值是否相等，成立为true，不成立为false
!=a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>a>b，判断a是否大于b，成立为true，不成立为false
>=a>=b，判断a是否大于等于b，成立为true，不成立为false
<a<b，判断a是否小于b，成立为true，不成立为false
<=a<=b，判断a是否小于等于b，成立为true，不成立为false

 2. 注意事项：

  • 关系运算符的结果都是boolean类型，要不为true，要么为false。
  • 如果把==写成了=，则成为了赋值运算。
public class Demo {
    public static void main(String[] args){
        int i=10;
        int j=20;
        int k=10;
        System.out.println(i==j); //输出false
        System.out.println(i==k); //输出true
        System.out.println(i!=j); //输出true
        System.out.println(i!=k); //输出false
        System.out.println(i>=j); //输出false
        System.out.println(i>=k); //输出true
        
        //不小心把==写成了=，则就会把j的值赋值给了i，然后输出i的值
        System.out.println(i=j); //输出为20
    }
}

9.6 逻辑运算符

 1. 逻辑运算符概述：是用来连接关系表达式的运算符，也可以直接连接布尔类型的常量或者变量。
 2. 逻辑运算符表格：

符号作用说明
&逻辑与a&b，a和b的结果都是true，结果为true，否则为false
丨逻辑或a丨b，a和b的结果都是false，结果为false，否则为ture
^逻辑异或a^b，a和b的结果不同为true，相同false
!逻辑非!a，结果与a的结果正好相反

 3. 代码块举例：

public class Demo {
    public static void main(String[] args){
        int i=10;
        int j=20;
        int k=30;
        System.out.println(i>j & i>k); //输出false
        System.out.println(i<j & i>k); //输出false
        System.out.println(i>j & i<k); //输出false
        System.out.println(i<j & i<k); //输出true
    }
}

9.7 短路逻辑运算符

 1. 短路逻辑运算符表格：

符号作用说明
&&短路与作用和&相同，但是有短路效果
丨丨短路或作用和丨相同，但是有短路效果

 2. 注意事项：

  • 逻辑与&，无论左边真假，右边都要执行。
  • 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
  • 逻辑或|，无论左边真假，右边都要执行。
  • 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
public class Demo {
    public static void main(String[] args){
        int i=10;
        int j=20;
        int k=30;

        //&& 有false则false；|| 有true则true
        System.out.println(i>j && i>k); //输出false
        System.out.println(i<j && i>k); //输出false
        System.out.println(i>j && i<k); //输出false
        System.out.println(i<j && i<k); //输出true

        //这里i++ >100为假，所以不会执行j++操作
        System.out.println(i++ >100 && j++ >100);
        System.out.println(i);  //输出为11
        System.out.println(j);  //输出为20
    }
}

9.8 三元运算符

 1. 三元运算符格式：关系表达式 ? 表达式1 : 表达式2; 范例：a>b ? a : b;
 2. 计算规则：

  • 首先计算关系表达式的值。
  • 如果值为true，表达式1的值就是运算结果。
  • 如果值为false，表达式2的值就是运算结果。

 3. 代码块举例：

public class Demo {
    public static void main(String[] args){
        int a=10;
        int b=20;

        //获取两个数据中的较大值
        int max=a>b ? a:b;

        System.out.println(max);
    }
}

9.9 三元运算符案例举例

案例1：动物园里有两只老虎，两只老虎的体重分别是180kg和200kg。请写程序判断两只老虎的体重是否相同。

public class Test1 {
    public static void main(String[] args){
        int weight1=180;
        int weight2=200;
        boolean b=weight1==weight2 ? true:false;
        System.out.println(b);
    }
}

案例2：一个寺庙住着三个和尚，他们的身高分别是150cm、185cm、165cm。请写程序获得三个和尚中的最高身高。

public class Test2 {
    public static void main(String[] args){
        int height1=150;
        int height2=185;
        int height3=165;
        
        //先求的前两个中的最高值用临时变量保存起来
        int tempmax=height1>height2 ? height1:height2;
        
        //再用前两个中的最高值和第三个身高值比较，求最大身高
        int max=tempmax>height3 ? tempmax:height3;
        System.out.println(max);
    }
}

十、数据输入

10.1 数据输入步骤

 1. 导包：import java.util.Scanner; 注：导包的动作必须出现在类定义的上面。
 2. 创建对象：Scanner sc=new Scanner(System.in); 注：上面这个格式里面，只有sc是变量名，可以变，其他的都不允许变。
 3. 接收数据： int x=sc.nextInt(); 注：上面这个格式里面，只有x是变量名，可以变，其他的都不允许变。

10.2 代码块举例

import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        //接收数据
        int x=sc.nextInt();
        
        //输出数据
        System.out.println("x:"+x);
    }
}

10.3 Scanner类介绍

 java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。
在这里插入图片描述

10.4 数据输入案例举例

案例：一个寺庙里住着三个和尚，他们的身高必须经过测量得出，请用程序实现获取这三个和尚的最高身高。

import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入第一个和尚的身高:");
        int height1=sc.nextInt();

        System.out.println("请输入第二个和尚的身高:");
        int height2=sc.nextInt();

        System.out.println("请输入第三个和尚的身高:");
        int height3=sc.nextInt();

        int tempmax=height1>height2 ? height1:height2;
        int max=tempmax>height3 ? tempmax:height3;

        //输出数据
        System.out.println(max);
    }
}

十一、分支语句

11.1 流程控制

 1. 流程控制语句分类：

  • 顺序结构
  • 分支结构
  • 循环结构

 2. 顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

11.2 if语句

 1. 语句格式：

if(关系表达式){
   语句体;
}

 2. 执行流程：

  • 首先计算关系表达式的值。
  • 如果关系表达式的值为true就执行语句体。
  • 如果关系表达式的值为false就不执行语句体。
  • 继续执行后面的语句内容。
public class Demo {
    public static void main(String[] args){
       int a=10;
       int b=20;
       if(a==b){
           System.out.println("a等于b");  //a不等于b，这行未执行
       }
        System.out.println("结束");
    }
}

11.3 if…else结构

 1. 语句格式：

if(关系表达式){
    语句体1;
}
else{
    语句体2;
}

 2. 执行流程：

  • 首先计算关系表达式的值。
  • 如果关系表达式的值为true就执行语句体1。
  • 如果关系表达式的值为false就执行语句体2。
  • 继续执行后面的语句内容。
//需求：判断a和b两个数是否相等
public class Demo {
    public static void main(String[] args){
       int a=10;
       int b=20;
       if(a==b){
           System.out.println("a等于b");
       }
       else{
           System.out.println("a不等于b");
       }
        System.out.println("结束");
    }
}

11.4 案例分析1

案例1：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。

import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        //接收数据
        int x=sc.nextInt();
        
        //判断奇偶数
        if(x%2==0){
            System.out.println(x+"是偶数");
        }
        else{
            System.out.println(x+"是奇数");
        }
    }
}

11.5 if…else…if结构

 1. 语句格式：

if(关系表达式){
    语句体1;
}
else if(关系表达式2){
    语句体2;
}
......
else{
    语句体n+1;
}

 2. 执行流程：

  • 首先计算关系表达式的值。
  • 如果关系表达式的值为true就执行语句体1，如果关系表达式的值为false就计算关系表达式2的值。
  • 如果关系表达式的值为true就执行语句体2，如果关系表达式的值为false就计算关系表达式3的值。
  • ………………
  • 如果没有任何关系表达式的值为true，则执行语句体n+1。
//需求：从键盘1-7数字上录入一个数字，输出对应的星期几
import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        //接收数据
        int week=sc.nextInt();

        if(week==1){
            System.out.println("星期一");
        }
        else if(week==2) {
            System.out.println("星期二");
        }
        else if(week==3) {
            System.out.println("星期三");
        }
        else if(week==4) {
            System.out.println("星期四");
        }
        else if(week==5) {
            System.out.println("星期五");
        }
        else if(week==6) {
            System.out.println("星期六");
        }
        else{
            System.out.println("星期日");
        }
    }
}

11.6 案例分析2

案例2：小明快考试了，小明爸爸说，会根据不同的考试成绩，送小明不同的礼物，请用程序实现小明到底该获得什么样的礼物。

import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入一个分数：");
        //接收数据
        int score=sc.nextInt();

        if(score>100 || score<0){
            System.out.println("你输入的分数有误");
        }
        else if(score>=95 && score<=100) {
            System.out.println("奖励山地自行车一辆");
        }
        else if(score>=90 && score<95) {
            System.out.println("奖励游乐场玩一次");
        }
        else if(score>=85 && score<90) {
            System.out.println("奖励变形金刚玩具一个");
        }
        else if(score>=80 && score<85) {
            System.out.println("奖励吃大餐一顿");
        }
        else{
            System.out.println("无奖励");
        }
    }
}

11.7 switch语句

 1. 语句格式：

  • case：后面的是要和表达式进行比较的值。
  • break：表示中断、结束的意思，用来结束switch语句。
  • default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
switch(表达式) {
     case 值1:
         语句体1;
         break;
     case 值2:
         语句体2;
         break;
      default:
         语句体n+1;
         break;
}

 2. 执行流程：

  • 首先计算表达式的值。
  • 依次和case后面的值进行比较，如果有对应的值，就执行相应的语句，在执行的过程中，遇到break就会结束。
  • 如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。
//需求：从键盘1-7数字上录入一个数字，输出对应的星期几
import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        //接收数据
        int week=sc.nextInt();

        switch(week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的星期数有误");
                break;
        }
    }
}

11.8 案例分析3

案例3：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
春：3、4、5
夏：6、7、8
秋：9、10、11
冬：12、1、2

import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        //创建对象
        Scanner sc=new Scanner(System.in);

        //接收数据
        int month=sc.nextInt();

        //采用case穿透
        switch(month) {
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("你输入的月数有误");
                break;
        }
    }
}

 注意事项： 在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，继续向下运行，直到遇到break或者整个switch语句结束。

十二、循环语句

12.1 for循环语句

 1. 语句格式：

for(初始化语句;条件判断语句;条件控制语句){
       循环体语句;
}

 2. 执行流程：

  • ① 执行初始化语句。
  • ② 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行。
  • ③ 执行循环体语句。
  • ④ 执行条件控制语句。
  • ⑤ 回到②继续执行。
//需求：在控制台上输出5次 "HelloWorld"
public class Demo {
    public static void main(String[] args){
        for(int i=1;i<=5;i++){
            System.out.println("HelloWorld");
        }
    }
}

12.2 案例分析

案例：在控制台输出所有的水仙花数。水仙花数是一个三位数，且个位、十位、百位的数字立方和等于原数。

public class Demo {
    public static void main(String[] args){
        for(int i=100;i<1000;i++){
            int ge=i%10;
            int shi=i%100/10;
            int bai=i/100;
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
                System.out.println(i);
            }
        }
    }
}
//最后结果是：153、370、371、407

12.3 while循环语句

 1. 语句格式：

初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

 2. 执行流程：

  • ① 执行初始化语句。
  • ② 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行。
  • ③ 执行循环体语句。
  • ④ 执行条件控制语句。
  • ⑤ 回到②继续执行。
//需求：在控制台上输出5次 "HelloWorld"
public class Demo {
    public static void main(String[] args){
        int i=1;
        while(i<=5){
            System.out.println("HelloWorld");
            i++;
        }
    }
}

12.4 do…while循环语句

 1. 语句格式：

初始化语句;
do{
   循环体语句;
   条件控制语句;
}while(条件判断语句);

 2. 执行流程：

  • ① 执行初始化语句。
  • ② 执行循环体语句。
  • ③ 执行条件判断语句。
  • ④ 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行。
  • ⑤ 回到②继续执行。
//需求：在控制台上输出5次 "HelloWorld"
public class Demo {
    public static void main(String[] args){
        int i=1;
        do {
            System.out.println("HelloWorld");
            i++;
        }while(i<=5);
    }
}

12.5 三种循环区别

 1. 三种循环区别：

  • for循环和while循环先判断条件是否成立，然后决定是否执行循环体（即： 先判断后执行）。
  • do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（即： 先执行后判断）。

 2. for和while的区别

  • 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了。
  • 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用。

 3. 死循环格式：

  • for( ; ; ) {}
  • while(true) {}
  • do{} while(true);
  • 注意事项： while的死循环格式是最常用的，命令提示符窗口中Ctrl+C可以结束死循环。

12.6 跳转控制语句

 1. 跳转控制语句概述：

  • 用continue跳过某次循环体内容的执行。注意事项： 使用是基于条件控制的。
  • 用break终止循环体内容的执行。注意事项： 使用是基于条件控制的。

 2. 代码块举例：

public class Demo {
    public static void main(String[] args){
        for(int i=1;i<=5;i++){
            if(i%2==0){
                continue; //如果是break，则只有1输出
            }
            System.out.println(i);
        }
    }
}

12.7 Random

 1. 作用：用于产生一个随机数。
 2. 使用步骤：

  • 导包：import java.util.Random;，导包的动作必须在类定义的上面。
  • 创建对象：Random r=new Random();，上面这个格式里面，r是变量名，可以变，其他的都不允许变。
  • 获取随机数：int number=r.nextInt(10);，获取数据的范围 [0，10），包括0但不包括10。

 3. 代码块举例：

import java.util.Random;
public class Demo {
    public static void main(String[] args){
        Random r=new Random();
        int number=r.nextInt(10);
        System.out.println(number);
    }
}

十三、数组

13.1 数组定义格式

 1. 格式(1)：数据类型 [] 变量名;，范例：int [] arr;。含义：定义了一个int类型的数组，数组名是arr。
 2. 格式(2)：数据类型 变量名[];，范例：int arr[]。含义：定义了一个int类型的变量，变量名是arr数组。

13.2 数组初始化

 1. 数组初始化概述：就是为数组中的每个元素分配内存空间，并为每个数组元素赋值。
 2. 动态初始化举例：

public class Demo {
    public static void main(String[] args) {
        int[] arr=new int[3];
    }
}

 3. 静态初始化举例：

public class Demo {
    public static void main(String[] args) {
        int[] arr=new int[]{1,2,3};
        //int[] arr={1,2,3}; 这是简化格式
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

 4. 获得数组长度：System.out.println(arr.length);。

13.3 数组操作中的两个问题

 1. 索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题。

在这里插入图片描述

 2. 空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常。

在这里插入图片描述

十四、方法

14.1 方法概述

 1. 方法（method）：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
 2. 注意事项：

  • 方法必须先创建才能使用，该过程称为方法定义。
  • 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用。

14.2 方法的定义和调用

 1. 方法的定义：

public static void 方法名() {
   //方法体
}

 2. 方法调用的格式：方法名();，通常在main()方法中调用。
 3. 代码块举例：

public class Demo {
    public static void main(String[] args) {
        Number();
    }
    public static void Number() {
        int number=10;
        if (number%2==0){
            System.out.println(number+"是偶数");
        }
        else{
            System.out.println(number+"是奇数");
        }
    }
}

14.3 带参数方法的定义和调用

 1. 带参数方法定义：public static void 方法名( 参数 ) {......}，其中参数=数据类型 变量名，可以有一个参数，也可以有多个参数。
 2. 注意事项：

  • 方法定义时，参数中的数据类型和变量名都不能缺少，缺少任意一个程序将报错。
  • 方法定义时，多个参数之间使用英文逗号（,）分隔。

 3. 带参数方法调用：方法名(参数);，通常在main()方法中调用。

  • 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。

 4. 代码块举例：

public class Demo {
    public static void main(String[] args) {
        int number=9;
        Number(number);
        //或者直接Number(9);
    }

    public static void Number(int number) {
        if (number%2==0){
            System.out.println(number+"是偶数");
        }
        else{
            System.out.println(number+"是奇数");
        }
    }
}

 5. 形参和实参：

  • 形参：方法定义中的参数。等同于变量定义格式。
  • 实参：方法调用中的参数。等同于使用变量或常量。

在这里插入图片描述

14.4 带返回值方法的定义和调用

 1. 带返回值方法的定义：

public static 数据类型 方法名(参数) {
   return 数据;
}

 注意事项： 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。
 2. 带返回值方法的调用：数据类型 变量名=方法名(参数);。

  • 方法的返回值通常会使用变量接收，否则返回值毫无意义。

 3. 代码块举例：

public class Demo {
    public static void main(String[] args) {
        int number=9;
        boolean flag=Number(number);
        //或者直接Number(9);
        System.out.println(flag);
    }
    //偶数返回true，奇数返回false
    public static boolean Number(int number) {
        if (number%2==0){
            return true;
        }
        else{
            return false;
        }
    }
}

14.5 方法的两个注意事项

 1. 方法不能嵌套定义。

在这里插入图片描述
 2. void表示无返回值，可以省略return；也可以单独写return，但后面不加数据。

在这里插入图片描述

14.6 方法重载

 1. 方法重载概述：指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。条件如下：

  • 条件①：多个方法在同一个类中。
  • 条件②：多个方法具有相同的方法名。
  • 条件③：多个方法的参数不相同，类型不同或者数量不同。

在这里插入图片描述

 2. 方法重载特点：

  • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式。
  • 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关。换句话说不能通过返回值来判断两个方法是否相互构成重载。

在这里插入图片描述

 注意事项： 在调用时，Java虚拟机会通过参数的不同来区分同名的方法。

14.7 方法的参数传递

 1. 对于基本数据类型的参数，形式参数的改变，不影响实际参数的值。
 2. 代码块举例：

public class Demo {
    public static void main(String[] args) {
        int number=100;
        System.out.println("调用方法前："+number); //调用方法前：100
        Change(number);
        System.out.println("调用方法后："+number); //调用方法后：100
    }
    public static void Change(int number){
        number = 200;
    }
}

 3. 对于引用类型的参数，形式参数的改变，会影响实际参数的值。
 4. 代码块举例：

public class Demo {
    public static void main(String[] args) {
        int[] number={10,20,30};
        System.out.println("调用方法前："+number[1]); //调用方法前：20
        Change(number);
        System.out.println("调用方法后："+number[1]); //调用方法后：200
    }
    public static void Change(int[] number){
        number[1] = 200;
    }
}

14.8 案例分析

案例：用数组遍历通用格式对数组进行遍历。

public class Demo {
    public static void main(String[] args) {
        int[] number={10,20,30,40,50};
        Print(number);
    }
    public static void Print(int[] number){
        System.out.print("[");
        for(int x=0;x<number.length;x++){
            if(x== number.length-1){
                System.out.print(number[x]+"]");
            }
            else{
                System.out.print(number[x]+",");
            }
        }
    }
}

十五、Debug

15.1 Debug概述

 Debug：是供程序员使用的程序调试工具，它可用于查看程序的执行流程，也可以用来追踪程序执行过程来调试程序。

15.2 Debug操作流程

 1. 如何加断点：选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。

在这里插入图片描述

 2. 如何运行加了断点的程序：在代码区右键Debug执行。

在这里插入图片描述

 3. 看哪里：看Debugger（调试器）窗口。

在这里插入图片描述
 4. 点哪里：点箭头（或者F7）。

在这里插入图片描述
 5. 如何删除断点：选择要删除的断点，单击鼠标左键即可。

在这里插入图片描述

十六、类和对象

16.1 对象

 1. 对象：万物皆对象，客观存在的事物皆为对象。
 2. 生活举例图：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

16.2 类

 1. 类：类是对现实生活中一类具有共同属性和行为的事物的抽象。
 2. 对象的属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值。

在这里插入图片描述
 3. 对象的行为：对象能够执行的操作。

在这里插入图片描述
 4. 类和对象的关系：类是对现实生活中一类具有共同属性和行为的事物的抽象；而对象是能看得到摸得到的真实存在的实体。

在这里插入图片描述

16.3 类的定义

 1. 类的重要性：是Java程序的基本组成单位。组成为属性和行为。

  • 属性：在类中通过成员变量来体现（类中方法外的变量）。
  • 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）。

 2. 类的定义步骤：

  • ①：定义类。
  • ②：编写类的成员变量。
  • ③：编写类的成员方法。
public class 类名 {
       //成员变量
       变量1数据类型 变量1;
       变量2数据类型 变量2;
       ......

       //成员方法
       方法1;
       方法2;
}

 3. 定义一个电话类：

public class Phone {

    //成员变量：品牌和价格
    String brand;
    int price;

    //成员方法：打电话和发短信
    public void call() {
        System.out.println("打电话");
    }
    public void message() {
        System.out.println("发短信");
    }
}

16.4 对象的使用

 1. 创建对象：

  • 格式：类名 对象名=new 类名();。
  • 范例：Phone p=new Phone();。

 2. 使用对象：

  • 使用成员变量：①格式：对象名.变量名;。②范例：p.brand;。
  • 使用成员方法：①格式：对象名.方法名;。②范例：p.call();。

 3. 代码块举例：Phone类和Demo类在两个文件中。

public class Demo {
    public static void main(String[] args) {
        Phone p=new Phone();
        p.brand="小米";
        p.price=3000;
        System.out.println(p.brand);
        System.out.println(p.price);

        p.call();
        p.message();
    }
}

16.5 成员变量和局部变量

 1. 成员变量：类中方法外的变量。
 2. 局部变量：方法中的变量。

在这里插入图片描述
 3. 成员变量和局部变量的区别：

区别成员变量局部变量
类中的位置不同类中方法外方法内或者方法声明上
内存中的位置不同堆内存栈内存
生命周期不同随着对象的存在而存在，随着对象的消失而消失随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同有默认的初始值没有默认的初始值，必须先定义，赋值，才能使用

十七、private讲解

17.1 private关键字

 1. private是一个权限修饰符，可以修饰成员（包括变量和方法）。作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能被访问。
 2. 针对private修饰的成员变量，如果需要被其他的类使用，要提供相应的操作：

  • 提供get变量名()方法，用于获取成员变量的值，方法用public修饰。
  • 提供set变量名(参数)方法，用于设置成员变量的值，方法用public修饰。

 3. 代码块举例：创建两个Java文件。

在这里插入图片描述

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s=new Student();

        //为变量赋值
        s.name="张三";
        s.setAge(20);

        //调用show()方法
        s.show();
    }
}

public class Student {
    //成员变量
    String name;
    private int age;
    
    //成员方法
    public void setAge(int a) {
        if(a<0||a>120) {
            System.out.println("你输入的年龄有误");
        }
        else{
            age=a;
        }
    }
    public void show() {
        System.out.println(name+","+age);
    }
}

17.2 private关键字的使用

 一个标准类的编写：

  • 把成员变量用private修饰。
  • 提供对应的getXxx()或者setXxx()方法。

十八、this讲解

18.1 this关键字

 1. this关键字修饰的变量用于指代成员变量：

  • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量。
  • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。

在这里插入图片描述
 2. 什么时候使用this：在解决局部变量隐藏成员变量时使用。

18.2 this内存原理

在这里插入图片描述
在这里插入图片描述

十九、字符串

19.1 API讲解

 1. API（Application Programming Interface）：应用程序编程接口。
 2. Java API：指的就是JDK中提供的各种功能的Java类。这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

19.2 String讲解

 1. String类代表字符串，Java程序中的所有字符串文字（例如"abc"）都被实现为此类的实例。也就是说，Java程序中所有的双引号字符串，都是String类的对象。
 2. 字符串的特点：

  • 字符串不可变，它们的值在创建后不能被更改。
  • 虽然String的值是不可变的，但是它们可以被共享。

 3. String的构造方法：

方法名说明
public String()创建一个空白字符串对象，不含有任何内容
public String(char[] chs）根据字符数组的内容，来创建字符串对象
public String(byte[] bys）根据字节数组的内容，来创建字符串对象
String s= “abc”直接赋值的方式创建字符串对象，内容就是abc

 推荐使用直接赋值的方法得到字符串对象。

public class Demo {
    public static void main(String[] args) {
        String s1=new String();

        char [] chs={'a','b','c'};
        String s2=new String(chs);
        System.out.println(s2); //输出abc

        byte [] bys={97,98,99};
        String s3=new String(bys);
        System.out.println(s3); //输出abc

        String s4="abc";
        System.out.println(s4); //输出abc
    }
}

19.3 字符串的比较

 1. 使用==比较：

  • 基本类型：比较的是数据值是否相同。
  • 引用类型：比较的是地址值是否相同。

 2. 字符串对象直接用==比较的是地址值；要比较内容是否相同，是通过一个方法实现的，这个方法是equals()。

public class Demo {
    public static void main(String[] args) {
        char [] chs={'a','b','c'};
        String s1=new String(chs);
        String s2=new String(chs);
        System.out.println(s1==s2);  //输出：false

        String s3="abc";
        String s4="abc";
        System.out.println(s3==s4);
        System.out.println(s1.equals(s2)); //输出：true
        System.out.println(s1.equals(s3)); //输出：true
        System.out.println(s1.equals(s4)); //输出：true
    }
}

19.4 StringBuilder讲解

 1. StringBuilder是一个可变的字符串类，我们可以把它看成一个容器。这里的可变指的是StringBuilder对象中的内容是可变的。
 2. StringBuilder的构造方法：

方法名说明
public StringBuilder()创建一个空白字符串对象，不含有任何内容
public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
public class Demo {
    public static void main(String[] args) {
        StringBuilder s1=new StringBuilder();
        System.out.println(s1.length()); //0
        
        StringBuilder s2=new StringBuilder("hello");
        System.out.println(s2.length()); //5
    }
}

 3. StringBuilder的添加和反转方法：

方法名说明
public StringBuilder append(任意类型)添加数据，并返回对象本身
public StringBuilder reserve()返回相反的字符序列
public class Demo {
    public static void main(String[] args) {
        //创建对象
        StringBuilder s1=new StringBuilder();

        //添加
        s1.append("helloworld"); 
        System.out.println(s1); //输出：helloworld

        //反转
        System.out.println(s1.reverse()); //输出：dlrowolleh
    }
}

19.5 StringBuilder和String相互转换

 1. StringBuilder转换为String：s1.toString();。

public class Demo {
    public static void main(String[] args) {
        //创建对象
        StringBuilder s1 = new StringBuilder();

        //添加
        s1.append("helloworld");

        String s2 = s1.toString(); //String s2=s1;  这个是错误的
        System.out.println(s2); //输出：helloworld
    }
}

 2. String转换为StringBuilder：new StringBuilder(String s);。

public class Demo {
    public static void main(String[] args){
        String s1="hello";

        StringBuilder s2 = new StringBuilder(s1); //StringBuilder s2=s1; 这个是错误的
        System.out.println(s2); //输出：hello
        
        s2.append(10);
        System.out.println(s2); //输出：hello10
    }
}

最后总结

  有了C++基础，再学Java难度不大，但细节较多，建议大家整理一些笔记来帮助日后的复习。
  此篇内容字数尚可！如果大家发现有什么错误的地方，可以私信或者评论区指出喔（虚心请教，渴望大佬帮助）。希望能与大家共同进步，那么本期就到此结束，让我们下期再见！觉得不错可以点个赞以示鼓励喔！

冒冒菜菜
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java通过Comparator比较器对集合进行多属性连续分组内升降排序，以及null空值排最前或最后
hkl_Forever的博客
04-26 155
一、排序数据准备，分别对 one、two、three 三个属性进行连续分组内排序。连续排序，并且把被排序属性值为null的排在最后。连续排序，并且把被排序属性值为null的排在最后。
Java的基础语法学习笔记
09-02
里为大家整理了Java的基础语法学习笔记,包括关键词、运算符与基本的流程控制语句写法等,需要的朋友可以参考下
Java基础知识笔记（基础语法）
KorbinLee的博客
12-16 799
文章目录对Java平台的理解一、使用记事本编写helloworld程序二、配置环境变量三、Java基础知识标识符数据类型常量变量Java中的基本类型常量与类型定义变量数据类型转换自动转换强制转换算术运算符 对Java平台的理解 Java本身是一种面向对象的语言，最显著的特性有两个方面，一是所谓的“书写一次，到处运行”（Write once, run anywhere），能够非常容易地获得跨平台能力；另外就是垃圾收集（GC, Garbage Collection），Java 通过垃圾收集器（Garbage.
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础知识点总结归纳，超级全面！（2021版）
Java笔记
05-03 8万+
凯哥今天看了网上好多关于Java基础知识点汇总的博客，but，感觉都不尽如人意，要么不全面，要么不准确，要么排版太乱了！ 所以今天花了一天时间整理了一份Java基础知识点总结归纳，超级全面！希望对大家有帮助哈~ 由于本文篇幅过长，博主为了方便大家阅读和收藏，特意将本文转成了一份PDF版的文档。 需要PDF版的朋友可以关注微信公众号：Java团长，发送“基础知识”即可获取哈~ 一、Java概述 1、何为编程 编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程..
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
python入门之基础语法学习笔记
12-20
Python 中文编码 Python 文件中如果未指定编码，在执行过程会出现报错： Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。 解决方法为只要在文件开头加入 # -*...
java 学习笔记(入门篇)_java的基础语法
09-05
从基础语法开始，这个语法你也可以理解为英语或是汉语里面的语法，只不过大家各有各的特点和区别;那么在学习的过程中我们就要不断的积累重要的类和方法，这样写程序就会方便快捷了,下面就开始学习java的基础语法
狂神说Java学习笔记基础语法
07-16
狂神说Java学习笔记（笔记+源代码+图片）——基础语法
day02（java基础知识）学习笔记.docx
09-06
java的基础语法知识，详细涵盖了多个java的基础语法核心重点
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 337
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1443
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 605
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1342
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 760
consul官网地址。
迭代器模式
LuckFairyLuckBaby的博客
04-23 521
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 718
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
@Value
最新发布
思索的涟漪，突破自我
04-26 188
Value注解是 Spring 框架中的一个注解，用于从属性文件、环境变量、Java 系统属性等地方读取值，并将这些值注入到 Spring 管理的 Bean 中。
【Java并发知识总结 | 第八篇】Java并发线程知识总结
个银二粒的成长之路
04-21 1715
Java并发线程知识总结
java的不合规则标识符_Java笔记2基础语法
06-13
Java中的标识符必须满足以下规则： 1. 标识符可以包含字母、数字、下划线和美元符号（$）。 2. 标识符必须以字母、下划线或美元符号开头，不能以数字开头。 3. 标识符不能是Java中的关键字或保留字，例如，if、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冒冒菜菜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值