Java-课堂笔记

用Typora重新排版了下, 发现还有挺多问题, 手动排版好像也不识别. 太麻烦就这样了, 课堂笔记只是证明自己没有上课摸鱼, 这里的笔记是当初疫情上网课写的. 以后会按照路线重新学.

第一章 Java开发

1.1.1 Java概述

Java SE 标准版
Java EE 企业版
Java ME 小型版

1.1.2 Java语言特点

  1. 简单性
  2. 面对对象性
  3. 安全性
  4. 跨平台性
  5. 支持多线程

1.2 JDK的使用

Java开发环境，简称 JDK(Java Develpoment Kit)它是整个Java的核心，其中包括Java编译器、Java运行工具、Java文档生成工具、Java打包工具等。
SUN除了提供JDK，还提供了JRE(Java Runtime Enviroment)工具，它是Java运行环境，是提供给普通用户使用的。
bin目录：该目录用于存放一些可执行程序，如javac.exe（Java编译器）、java.exe（Java运行工具）、jar.exe（打包工具）和javadoc.exe（文档生成工具）等。

db目录：db目录是一个小型的数据库。从JDK 6.0开始，Java中引入了一个新的成员JavaDB，这是一个纯 Java 实现、开源的数据库管理系统。这个数据库不仅很轻便，而且支持JDBC 4.0所有的规范，在学习JDBC时，不再需要额外地安装一个数据库软件，选择直接使用JavaDB即可。

jre目录：“jre”是Java Runtime Environment的缩写，意为Java程序运行时环境。此目录是Java运行时环境的根目录，它包含Java虚拟机，运行时的类包、Java应用启动器以及一个bin目录，但不包含开发环境中的开发工具。

include目录：由于JDK是通过C和C++实现的，因此在启动时需要引入一些C语言的头文件，该目录就是用于存放这些头文件的。

lib目录：lib是library的缩写，意为Java类库或库文件，是开发工具使用的归档包文件。

src.zip文件：src.zip为src文件夹的压缩文件，src中放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码。

javac.exe 是一个Java编译器工具，它可以将编写好的Java文件编译成Java字节码文件
Java源文件的扩展名为.java
编译后生成的对应的Java字节码，文件的扩展名为.class

java.exe 是Java的运行工具，它会启动一个Java虚拟机( JVM )进程，Java虚拟机相当于一个虚拟的操作系统，专门负责运行由Java编译器生成的字节码文件( .class文件 )

1.3 第一个Java程序

class HelloWorld { 
    public static void(String[] args){
        System.out.println("这是第一个Java程序！")
    }
}

class是一个关键字，用于定义一个类。在Java中，类就相当于一个程序，所有代码都需要在类中书写

HelloWorld是一个类名

public static void (String[] args){}定义了一个main()方法,该方法是Java程序的执行入口

在编写程序时，程序中出现的空格、括号、分号等符号必须采用英文半角格式

使用 win + R 快捷键 输入cmd打开命令行窗口

cmd
cd <盘符>
cd <文件夹>
javac HelloWorld

文件夹选项打开文件扩展名

1.4 添加系统变量

cmd
javac //运行javac，检查是否安装
set path // 查看当前系统变量
%path& //表示引用原有的path变量

计算机右键-高级系统设计-环境变量

系统变量：
Path-编辑-添加(Java根目录/bin)
添加-CLASSPATH(Java根目录/lib)

1.6 Eclipse

快捷键
ALT + / Eclipse自动填充

Java可以使用中文类名 但是强烈不推荐

work：工作
space：空间 workspace
browse：浏览
src：source资源 java具体的内容
main method：main方法

第二章 Java编程基础

2.1 基本语法

  1. Java代码的基本格式

Java程序代码可分为结构定义语句和功能执行语句；
每条功能执行语句必须用分号结束

Java严格区分大小写

System.out.print("这是一个" +
        "Java程序"); // 可以使用 + 将两个字符串连接起来
 
// 这是一个Java程序

  1. 注释

    // 单行注释

    /* 多行注释
    */

    /**开头
    *一般作为文档注释
    */

  2. Java中的标识符

  3. 包名所有字母一律小写。例如：cn.itcast.test。

  4. 类名和接口名每个单词的首字母都要大写。如：ArrayList、Iterator。

  5. 常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。

  6. 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。

  7. 在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。

  8. Java中的关键字

注意：

  • 所有的关键字都是小写的
  • 程序中的标识符不能以关键字命名
  • const 和 goto 是保留关键字，虽然在 Java中还没有任何意义，但在程序中不能用来作为自定义的标识符
  • true、false 和 null 不属于关键字，它们是一个单独表示类型，不能直接使用
  1. Java常量

整型常量
二进制 0B ： 0、1
八进制 ： 0、1、2、3、4、5、6、7
十进制 ： 0、1、2、3、4、5、6、7、8、9
十六进制 0X ： 0、1、2、3、4、5、6、7、8、9、A、B、C、D、E、F

浮点数常量(可以通过指数形式来表示)
单精度float： 后面以F或f结尾
双精度double：后面以D或d结尾，默认为双精度可以不加符号

字符常量
存储一个单一字符：英文半角格式的单引号('')
同时可以将char类型的0~65535(2字节16位,2^16)范围内的占用两个字节，
字符常量不能为空

字符串常量
表示一串连续的字符：英文半角的双引号("")
字符串可以为空，长度为0

布尔常量
只有true和false两个值，用于区分一个事物的真或假
null常量
null常量只有一个值为null，表示引用对象为空

补充：
转义字符
1.0 和 1 不同：浮点数类型和整型

  1. 进制转换

短除法求二进制

短除法求二进制

1024 512 256 128 64 32 16 8 4 2 1
0 0 0 0 1 1 1 1 0 0 1
121 ⇨ 64+32+16+8+1=121 ⇨ 111 1001
用这个数减去表格上方的数字则加1，否则为0

二转八
2³=8
每三位二进制数，转换为一位十进制数即为八进制数(位数不足则需要用0补充)
121 ⇨ 111 1001 ⇨ 001,111,001 ⇨ 171

二转十六
2⁴=16
每四位二进制数，转换为一位十进制数即为十六进制数
121 ⇨ 111 1001 ⇨ 0111，1001 ⇨ 79

2.2 Java中的变量

  1. 变量的定义

应用程序随时可能产生一些临时数据，这些数据将会保存在内存单元中，每个内存单元都用一个标识符来表示。这些内存单元称为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值

  1. 变量的数据类型

变量的数据类型

(1) 整数类型变量：用于存储整数数值即没有小数部分的值
字节型 byte 8位(1字节) -2^7 ~ 2^7 -1 -128~127
短整型 short 16位(2字节) -2^15 ~ 2^15-1
整型 int 32位(4字节) -2^31 ~ 2^31-1
长整型 long 64位(8字节) -2^63 ~ 2^63-1

LONG类型的表示：
在后面添加l或L表示为long类型,但是数值的范围未超过int的范围可以不写,推荐大写方便区分

范围的来源：
2^8 = 512 ; -2^7 + 0 + 2^7-1 = 512位

数据的表示：字(word)、字节(byte)、位(bit)
1字=2字节(1 word = 2 byte)
1字节=8位(1 byte = 8bit)

1 Byte = 8 Bits
1 KB = 1024 Bytes
1 MB = 1024 KB
1 GB = 1024 MB

1 kb = 1024 bytes =2^10 bytes
1 mb = 1024 kb = 2^20 bytes
1 gb = 1024 mb = 2^30 bytes

1 汉字 = 2 byte = 16 bit （这里不是很准确，当编码不同的时候，1个汉字所占的字节数也会有所不同，有些编码是占 2个字节，有些则不是，可能是 3个或者 4个）

(2) 浮点数类型变量：用来存储小数数值
单精度浮点数 float 32位(4字节)
双精度浮点数 double 64位(8字节)

float类型赋值后面要加上F或f；double类型赋值后面要加上D或d
在程序中也可以为浮点数赋值一个整数(后面不写后缀即可)

(3)字符类型变量：用于存储一个单一字符，用char表示

  • char 都占用 2 个字节

也可以赋值为 0~65535范围内的整数，计算机会自动将这些整数转换为对应的字符
65535 = 0 + 2^16-1 char占用2个字节，一个字节占用8位

char c1 = 97;
System.out.println("c1 = " + c1); // c1 = a
 
c1 = "a" + 1;
System.out.println("c2 = " + c2);

(4) 布尔类型变量：用于存储布尔值，该类型只有两个值，true和false

  1. 变量的类型转换

把一种数据类型的值赋值给另一种数据类型的变量，需要进行类型转换

(1) 自动类型转换(隐式类型转换)：指两种数据类型在转换的过程中不需要显式地进行声明
要实现自动类型转换，必须满足两个条件：

  • 两种数据类型相互兼容
  • 转换类型的取值范围大于原来类型的取值范围

1)整数类型之间可以实现转换：
byte类型可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给int、long类型的变量，int类型的数据可以赋值给long类型的变量

2)整数类型转换为float类型，
如byte、char、short、int类型的数据可以赋值给float类型的变量

3)其他类型转换为double类型，
如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量

String str = "1";
System.out.println(str + 1); // 11
// +(拼接) 字符串用+和其他类型输出，将会一起转换为字符串类型
 
	1 字符串转换成数据,字符串转换成整数：
 
String MyNumber ="1234";
int MyInt = Integer.parseInt(MyNumber);
 
	2 数据转换成字符串,整数转换成字符串：
 
int MyInt = 1234;
String MyString = "" + MyInt;
 
	其它数据类型可以利用同样的方法转换成字符串。

(2) 强制类型转换(显式类型转换)：两种数据类型之间的转换需要进行显式声明 会损失精度
两种类型相互不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，格式如下:

目标类型 变量 = (目标类型)值

强制类型转换导致的溢出错误，例如：

int i = 289;
byte b = (byte)i;
System.out.println("i = " + i);
System.out.println("i = " + b);
 
33 //byte只有8位，289(289 = 256 + 33)转换为byte会导致数据溢出，仅有33

变量在表达式中进行运算时，也可能发生自动类型转换，这就是表达式数据类型的自动提升
例如一个byte类型的变量在运算期间会自动提升为int型

byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2; // 两个byte类型变量相加，赋值给一个byte类型
System.out.println("b3 = " + b3);

结果IDE报错，因为byte运算会自动提升为int型，需要强制类型转换

  1. 变量的作用域

变量需要先定义后使用，变量还需要在它的作用范围内才能被使用

public class Main {
    public static void main(String[] args) {
        int x = 1;
        // int y = x;
        {
            int y = 2; // 重复定义变量
            System.out.println("x = " + x);
            System.out.println("y = " + y)
        }
        y = x
        System.out.println("x = " + x); // error
        System.out.println("y = " + y);
    }
}
ublic class Main {
    public static void main(String[] args) {
        int x = 1;
        // int y = x;
        {
            int y = 2; // 重复定义变量
            System.out.println("x = " + x);
            System.out.println("y = " + y)
        }
        y = x
        System.out.println("x = " + x); // error
        System.out.println("y = " + y);

寻找定义域：在定义变量忽略掉成对的大括号的前提下，向上找一个单独的左括号

2.3 Java中的运算符

  1. 算术运算符

在数学运算中最常见的就是加减乘除，被称作四则运算。Java中的算数运算符就是用来处理四则运算的符号，这是最简单、最常用的运算符号。

+ 正号
- 负号
+ 加
- 减
* 乘
/ 除
% 取模(求余数)
++i 自增 先增加，后引用
i++ 自增 先引用，后增加
--i 自减 同理
i-- 自减 同上

算数运算符看上去简单，也容易理解，但在实际使用时还有很多需要注意的问题，具体如下：

  • 在进行自增++和自减--的运算时，如果运算符++或--放在操作数的前面则是先进行自增或自减运算，在进行其他运算。反之，如果运算符放在操作数的后面则是先进行其他运算在进行自增或自减运算
  1. 赋值运算符

将常量、变量或表达式的值赋值给某一个变量

= 赋值
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
%= 模等于(求余数)

需要注意几个问题：

  1. 在Java中可以通过一条赋值语句对多个变量进行赋值

  2. 除了 "=",其他的都是特殊的赋值运算符，以 "+=" 为例， x += 3 就相当于 x = x + 3，首会进行加法运算 x+3，再将运算结果赋值给变量x

  3. -=、*=、/=、%=赋值运算符都可以依此类推

    int j = 1;
    j += 3; // 4: j = j + 3

部分赋值不可以运行

int x = 5;        // 可以
int a = 5, b = 5; // 可以
int y = z = 5;    //不可以

为变量赋值时，当两种类型彼此不兼容或者目标类型取值范围小于原类型时，需要进行强制类型转换。此时可以使用 +=、-=、*=、%=来进行赋值运算，强制类型转换就会自动完成，程序不需要进行显式声明

int x = 288;
byte s = 1;
s = (byte) (s + x);
s += x; //33
System.out.println(s)
  1. 比较运算符

比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即 true 或 false

== 等于
!= 不等于
< 小于
> 大于
<= 小于等于
>= 大于等于
 
System.out.println(128 == 127);     //false
System.out.println(128 == (127+1)); //true
System.out.println(true == false);  //false
System.out.println(4 >= 4);         //true
  1. 逻辑运算符

& 与 一假则假，全真则真
true & true // true
true & false // false
false & false // false
false & true // false

| 或 一真则真，全假则假
true | true // true
true | false // true
false | false // true
false | true // false

^ 异或
true ^ true // false
true ^ false // true
false ^ false // false
false ^ true // true

! 非
!true // false
!false // true

&& 短路与
true && true // true
true && false // false
false && false // false
false && true // false

|| 短路或
true || true // true
true || false // true
false || false // true
false || true // false

int m = 4;
int n = 5;
System.out.println(m > 4 & n++>5); //false
System.out.println("n = " + n); //6
System.out.println(m > 4 && n++>5); //false
System.out.println("n = " + n); //5
System.out.println();

在使用逻辑运算符的过程中，需要注意的几个细节:

  1. 逻辑运算符可以针对结果为布尔值的表达式进行运算

  2. 运算符 "&" 和 "&&" 都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。

  3. 当运算符 "&" 和 "&&" 的右边为表达式时，两者在使用上还有一定的区别

  4. 如果使用 "&&" 进行运算，当左边的 false 时，右边的表达式则不会进行运算，因此 "&&" 被称为短路与

  5. 短路与和短路或运算，左侧为ture/false右侧都不运算，可以用作程序优化

  6. 运算符的优先级

在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，通常把这种顺序称作运算符的优先级。

1 . [] ()
2 ++ -- ~ !
3 * / %
4 + -
5 << >> >>>
6 < ><= >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?:
14 = *= /= %= += -= <<= >>= &= ^= |=

2.4 选择结构语句

  1. if条件语句

(1)If语句

满足条件就进行处理

if (条件语句) {
    代码
}

上述格式中，判断条件是一个布尔值，当条件为True时，{} 中的代码才会执行

boolean isUseful;
isUseful = false;
if(isUseful) //if判断为假，后一句不执行
     System.out.println("全角模式有用嘛" + isIseful);
Syste.out.println("End...Yet?");
 
isUseful = true;
is(isUseful) //if判断为真，执行if后面的语句
    System.out.println("半角模式有用" + isUseful);
 
int num = 6;
if(num < 10)
    num++; //if以分号结束，执行多条语句需要用大括号{}
    System.out.println(num + "< 10");
System.out.println("End...");

(2)if...else 语句

满足某种条件就进行某种处理，否则就进行另一种处理

if (判断条件) {
    执行语句1
    ......
} else{
    执行语句2
    ......
}

上述格式中，判断条件是一个布尔值。
当判断为True时，if后面的{}的执行语句1会执行
判断为false时，else后面的{}的执行语句2会执行

int num = 11
if(num <= 10) {
    System.out.println(num + " < 10 ");
}else {
    System.out.println(num + " > 10, Then dont puls");
}
System.out.println("num : " + num);
System.out.println("End...");
 
/**
/*判断奇偶数
    */
 
public class Main {
    public static void main(String[] args) {
       int number = 20;
       if(number % 2 == 0){
           System.out.println(number + "偶数");
       }else {
            System.out.println(number + "奇数");
        }
    }
}
//除法不能实现，因为仅除一次，除了可以一次实现的数值，都不能正确得到结果
//取余可以最后得出可以判断的结果

(2.5)三元运算

在Java判断中有一种特殊的运算叫三元运算，它和 if-else 语句类似，语法如下:

判断条件 ? 表达式1 : 表达式2

三元运算会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。

例，求两数x, y 中的较大者，如果用if...else语句来实现，代码如下：

int x = 0;
int y = 1;
iant max;
if(x > y) {
    max = x;
} else {
    max = y;
}

上面的代码运行之后，变量max的值为1.上述代码片段中的 if...else 语句可以使用下面的三元运算符来替换。

int max = x > y ? x : y

(3) if...else if...else 语句

用于对多个条件进行判断，进行多种不同的处理。例，对学生成绩划分：

/*成绩判断
*/
int score = 80;
if(score >= 90){
    System.out.println("优秀");
}else if(score >= 80){
    System.out.println("良好");
}else if(score >= 60){
    System.out.println("及格");
}else{ //elseif 和 else是可选的
    System.out.println("喜提补考");
}

上述格式中，判断条件为一个布尔值。当判断条件1为 True时，if后面{}中的执行语句1会执行。
当判断条件1为false时，会继续执行判断条件2；如果为true则执行语句2，以此类推
如果所有的判断条件都为false，则意味着所有条件均为满足，else后面的执行语句 n+1会执行

int number = 9;
String str = number % 2 == 0? number + " 偶数": number + " 奇数";
System.out.println(str);
  1. switch条件语句

只能针对某个表达式的值做出判断，从而决定程序执行哪一段代码

// 编写一个判断
public class Switch {
    public static void main(String[] args) {
        int week = 1;
        switch (week) {
            // 假如 case后不写break,则会一直向下运行，但也可以利用这个性质
            case 1:
            case 2:
            case 3:
           case 4:
           case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
 
            default:
                System.out.println("输入错误，请重试！");
                break;
        }
    }
}

在JDK5之前，switch只能使用byte、short、char、int类型的值

2.5 循环结构语句

  1. while 循环语句

根据条件判断来决定是否执行大括号内的执行语句，while只要条件成立，[}内的执行语句就会执行直到条件不成立，while循环结束。

while (循环条件) {
    执行语句
    ...
}
 
int i = 1;
while(i <= 100) {
    // i == 100 不会执行
    // i != 100 执行到99结束
    System.out.println(i);
    // System.out.print(i + " "); 不换行的语句
    i++;
}
System.out.println("END")
// 注意临界值

例题：每天存200，攒够1e小目标，利用while

int money = 0;
int day = 0;
while (i <= 100000000) {
    System.out.println(money);
    money += 200; // money = money + 200
}
System.println("共需要" + count + "天，即" + count/365.0 + "年");

  1. do...while 循环语句

    do {
    执行语句
    ...
    } while (循环条件);

在上面的语法结构中，关键字do后面的{}中的执行语句时循环体。do...while 循环语句将循环条件放在了循环体的后面。就是说，循环体至少会循环一次，然后再根据条件来决定是否执行

do {
    System.out.println(i);
    i++;
} while(i <= 100);

while : 先判断，再执行
do while:先执行，再判断

  1. for循环

用于已知次数循环的情况下

for (起始化 ; 循环条件 ; 操作表达式) {
    执行语句
    ...
}
 
for (1;2;3) {
    4
}
// 第一步，执行1
// 第二步，执行2，如果判断条件为true，执行第三步；如果判断结果为false，执行第五步
// 第三步，执行4
// 第四步，执行3，重复执行第二步
// 第五步退出循环
 
//输出100以内的整数
for(int i = 0 ; i <= 100 ; i++) {	//三个都没有也不影响程序运行
                                    //但是没有循环条件会造成无限循环函数
    if(i % 2 == 0) {
        System.out.println(i + "是偶数")
    }
}
 
//输出1+2+3+4+5+...+100
//定义从1开始，少一次循环，节省资源？反正不从0开始
int sum;
for(int i = 1 ; i<=100 ; i){
        sum += i
}
System.out.printlf("1-100的和为" + sum);
  1. 循环嵌套

嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语句结构

while、do...while、for循环

//用嵌套输出星号
for(int i = 0 ; i < 10 ; i++) {
    for(int j = 1 ; j <= i ; i++) {
        System.out.print("*")
    }
    System.out.print("\n"); // println("")
}
  1. 跳转语句(break、continue)

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有 break 和 continue

break 语句

在switch语句中，break作用为终止某个 case 并跳出 switch 结构，并且继续执行后面的代码

for(int i = 1 ; i <= 4 ; i++) {
    System.out.println(i);
    if(i == 3) {
        break;
    }
}
System.out.println("END");

continue 语句

continue作用是终止本次循环，执行下一次循环

for(int i = 1 ; i <= 4 ; i++) {
    if(i == 2){
        continue;
    }
    System.out.println(i);
}
System.out.println("END");

任务 2-2 猜数字游戏

//1. 电脑随机生成一个数字
new Random().nextInt(10); //0-10
//2. 输入一个数字
Scanner scan = new Scanner(System.in);
int input = scan.nextInt();
//3.比较两个数字大小, 直到猜对为止
//for(; randNum != input ; )
while(randNum != inputNum){
    if(randNum != input){
        System.out.println("你输入的数字小了！");
    } else {
        System.out.println("你输入的数字大了！");
    }
    System.out.println("恭喜你，猜对了 WoW！");
}

2.6方法

1.什么是方法

方法就是一段可以重复调用的方法

public class MethodLearn {
        public static void main (String[] args) {
            int width = 6;
            int height = 4;
 
            for(int i = 0 ; i < height ; i++) {
                for(int j = 0 ; j < width ; j++) {
                    System.out.println("*");
                }
                System.out.println("\n");
            } // 4行6列的矩形
 
            System.out.println();
 
            for(int i = 0 ; i < 5 ; i++) {
                for(int j = 0 ; j < 8 ; j++) {
                    System.out.println("*");
                }
                System.out.println("\n");
            } // 5行8列的矩形
 
            // 1.抽取重复的代码，放在main函数外面
            // 2.为这段代码起别名
            // 3.使这段代码具有通用性：将具体参数用变量替换
        }
        public static void printG(int height, int width) {
            for(int i = 0 ; i < height ; i++) {
                for(int j = 0 ; j < width ; j++) {
                    System.out.println("*");
                }
                System.out.print("\n");
            } // 4行6列的矩形
        }
}
 
public class MethodLearn {
        public static void main (String[] args) {
            int width = 6;
            int height = 4;
 
            printG(4, 6);
            printG(5, 8);
            printG(5, 5);
 
            // 1.抽取重复的代码，放在main函数外面
            // 2.为这段代码起别名
            // 3.使这段代码具有通用性：将具体参数用变量替换
        }
        public static void printG(int height, int width) {
            for(int i = 0 ; i < height ; i++) {
                for(int j = 0 ; j < width ; j++) {
                    System.out.print("*");
                }
                System.out.print("\n");
            }
            System.out.println();
        }
}

声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名 ([参数类型 参数名1, 参数类型 参数名2, ...]) {
    执行语句
    ...
    return 返回值;
}

修饰符：方法的修饰符比较多，有限定访问权限、静态修饰符static 、最终修饰符final等
返回值类型：用于限定方法返回值的数据类型
参数类型：用于限定调用方法时传入参数的数据类型
参数名：是一个变量，用于接收调用方法时传入的数据
return 关键字：用于结束方法以及返回方法指定类型的值
返回值：被return语句返回的值，该值会返回给调用者

  • 特别需要注意的是方法中的“参数类型 参数名1, 参数类型 参数名2”被称作参数列表，用于描述方法在被调用时需要接收的参数

  • 如果方法不需要接收任何参数，则参数列表为空，()内不写任何内容

  • 方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值返回值类型要声明void，此时return语句可以省略

    // 写一个方法，计算两个整型数字的和并输出
    public class MethodLearn {
    public static void main (String[] args) {
    add(3,4);
    add(7,8);
    System.out.println("END");
    }
    public static void add(int n1, int n2) {
    int sum = n1 + n2;
    System.out.println(n1 + "+" + n2 + "=" + sum);
    }
    }

    // void:空，没有返回值
    // 想要结果类型的和
    public class MethodLearn {
    public static int add(int n1, int n2) {
    int sum = n1 + n2;
    return sum; // retuen后面不可以有代码!!
    }

    public static void main (String[] args) {
    int total = add(3,4);
    add(7,8);
    System.out.println("END");
    }
    }

2.方法的重载

public class MethodLearn {
            // 注意！参数名不同不叫重载，只看参数的数据类型
            // 重载与返回值类型、有无返回值无关
            
            // 重载：方法名相同
        public static void add(int n1, int n2) {
            int sum = n1 + n2;
            System.out.println(n1 + "+" + n2 + "=" + sum);
        }
            //1. 参数个数相同，数据类型不同
        public static void add(double n1, double n2) {
            double sum = n1 + n2;
            System.out.println(n1 + "+" + n2 + "=" + sum);
            //2. 参数个数不同
        public static void add(int n1, int n2, double n3) {
            double sum = n1 + n2;
            System.out.println(n1 + "+" + n2 + "=" + sum);
            
            //3. 参数个数相同，数据类型相同，参数数据顺序不同
        public static void add(double n1, int n2, int n3) {
            double sum = n1 + n2;
            System.out.println(n1 + "+" + n2 + "=" + sum);
            
    public static void main (String[] args) {
        }
}

实例

九九乘法表

for(int i =1 ; i <= 9 ; i++) {
    for(int j = 1 ; j <= i ; j++) {
        System.out.println(j + "*" + i + "=" + i * j + '\t');
    }
    System.out.println();
}

猜数字三次机会

//导入Java包
import java.util.Random;
import java.util.Scanner;
 
import java.util.*; // 导入util所有包
 
int tag = 0;
int randomNumber = new Random().nextInt(10); //生成10以内的随机数
System.out.println("随机数已生成!");
Scanner sc = new Scanner(System.in);
// 三次循环 判断输入次数
for(int i = 1 ; i <= 3 ; i++) {
    System.out.println(请输入数字);
    int enterNumber = sc.nextInt();
    if(enterNumber != randomNumber) {
        
        if(enterNumber > randomNumber) {
            System.out.println("大了");
        } else {
            System.out.println("小了");
        }
    } else {
        tag = 1;
        break;
    }
}
 
if(tag == 1) {
    System.out.println("猜对了!");
} else {
    System.out.println("机会用完了");
}
 
// 第二种实现
int randNum = new Random().nextInt(10);
System.out.println("请输入数字：");
Scanner sc = new Scanner (System.in);
int inputNum = sc.nextInt();
int i=0;
    while(i<4) {
        if(randNum > inputNum) {
            System.out.ptintln("小了");
        } else if (randNum < inputNum) {
            System.out.ptintln("大了");
        } else {
            System.out.ptintln("猜对了");
            break;
        }
        i++;
        
        if (i==3) {
            System.out.ptintln("机会用完");
            break;
        }
        System.out.println("请输入数字");
        inputNum = sc.nextInt;
    }

2.7数组

一次声明多个数据，但是数组中存放同一类型的数据

int i;          // 定义一个int类型变量
int [] j;       // 定义一个int类型数组
 
j = new int[5]; // 指明数组可以存储的数据量
int [] k = new int[5];
 
float [] f = new float[6];     // f[0] f[1] f[2] f[3] f[4] f[5]
boolean [] b = new boolean[7]; // b[0]...b[6]
String[] s = new String[9];    // s[0]...s[8]
 
// 数组可以不赋初值直接引用
System.out.println(j[0]);
System.out.println(f[1]);
 
System.out.println("数组j的长度是：" + j.length);
System.out.println("数组f的长度是：" + f.length);
System.out.println("数组b的长度是：" + b.length);
 
int n = 9;
int [] m = new int[] {9,1,3,4,6};
int [] x = {3,4,5,7,9,2};
 
System.out.println("数组m的长度是：" + m.length);
System.out.println("数组x的长度是：" + x.length);
System.out.println("m[0]=" + m[0]);
System.out.println("m[4]=" + m[4]);
 // System.out.println("m[5]=" + m[5]); 
// 数组越界异常：ArraryIndexOutOfBoundsException
//只能使用声明的部分
 
// int [] y = new int[6] {234,345,457};
// 不要同时赋值并且限定数组长度!

2.数组常见操作

① 数组遍历

int [] m = new int[] {9,1,3,4,6};
 
System.out.println(m[0]);
System.out.println(m[1]);
System.out.println(m[2]);
System.out.println(m[3]);
System.out.println(m[4]);
 
for(int index = 0 ; index < m.length ; index++) { // 数组长度减一
    System.out.println("m[" + index + "] = " + m[index]);
}
// length是java中的方法用于计算数据,每次循环都会调用一次length方法,会多消耗资源
// final static int N = 7; // 声明常量
// int [] k = new int[N];

② 数组最值

//求最大值
 
// 1.设定第一个最大值
// 2.用第一个数和其他数比较,若第一个数大,不变化; 其他值大,其他值应为目前的最大值
// 3.重复步骤2,直到比较到最后一个值
 
int [] m = new int[] {9,1,3,4,6};
int max = m[0];
 
for(int index = 1 ; index < m.length ; index++) {
    if(max < m.[index]) {
        max = m[index];
    }
    System.out.println("最大值为：" + max);
}
 
//求最小值
int min = m[0];
for(int index = 1 ; index < m.length ; index++) {
    if(min > m.[index]) {
        min = m[index];
    }
}
System.out.println("最小值为：" + min);

③ 数组排序

// Java自带排序
int [] arr = [1, 3, 7, 2, 10];
Arrays.sort(arr);
for(int i = 0 ; i < arr.length ; i++) {
    System.out.println(arr[i] + " ");
}

eclipse技巧

CTRL + 点击方法名 ==> 快速定位到方法
方法传递基本数据类型——传递数据
方法传递引用数据类型——传递地址

  1. 多维数组

第 1 种方式

int [] [] arr = new int [1] [2];

第 2 种方式

int [] [] arr = new int [1] [];
//只声明行不声明列
arr[0] = new int[1];
arr[1] = new int[2];
arr[2] = new int[3];

第 3 种方式

int [] [] arr = {{1, 2},{2,3}};

通过角标对元素的访问

第三章 Java 面向对象 （上）

3.1 面向对象的概念

面向过程——只编写需要的功能
面向对象——提前编写所有需要的功能(不管当前需不需要)

面向对象的特点：

  1. 封装性

封装就是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界直到具体实现细节

黑盒测试

  1. 继承性

描述类与类之间的关系，通过继承可以在无需重新编写原有类的情况下，对原有类的功能进行拓展

  1. 多态性

程序中允许出现重名，指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现除不同的行为

同一物品在不同作用下发挥不同的功能

3.2 类与对象

类——某一类事物的抽象描述
对象——用于表示显示该类事物的个体

  1. 类的定义

在面对对象中，最核心的就是对象。为了在程序中创建对象，首先需要定义成一个类。类是对象抽象的抽象，用于描述一组对象的共同特征和行为。

类中可以定义成员变量和成员方法，成员方法用于描述对象的特征，也被称为属性；成员方法用于描述对象的行为，可简称方法

方法和属性中有重复变量，变量就近原则，变量的内容为方法中的内容
方法中没有声明属性中的存在的变量，变量内容为属性的声明内容

一般IDE中将光标停在变量中，就会高亮引用的变量

  1. 对象的创建和引用

Java程序中使用 new关键字创建对象

类名 对象名称 = new 类名();

例：创建一个Person类

public class Person {
    
    // 属性：成员变量
    String name;    // 名字
    int age;        // 年龄
    String gender;  // 性别
    
    // 方法：成员方法
    public void speak() {
        System.out.println("大家好,我是" + name + "!")
    }
    
    public void sleep(){
        System.out.println(name + "睡觉")
    }
}

创建对象后，可以通过对象的引用来访问对象的对象的所有成员

对象引用.对象成员

例：调用Person类

public static void main(String[] args) {
    int i;
    Person p1 = new Person();
    // Person内存地址指向p1
    
    p1.name = "小明";
    p1.age  = "12";
    p1.gender="男";
    p1.slepp();
    
    p2.speak();
    // p2没有赋值，只会输出变量的初始值
}

2.1 成员变量的起始化值

byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0D
char 空字符，'\u0000'
boolean false
引用数据类型 null

2.2 垃圾回收机制

    Person p2 = new Person();
// 实例化p2,此时p2储存Person的内存地址,p2指向Person
 
    p2.name = "小红";
    p2.age  = "13";
    p2.gender="女";
//给对象赋值
 
    Person p2 = null;
// 给p2 赋值为空，导致p2指向null,使原来的p2的Person内存空间成为垃圾
 
    p2.sleep();

4 类的封装

使用 private 关键字 封装类，但是可以通过其他的中间函数实现封装类中属性的交换，因此可以检测用户输入进类的数据的合法性，从而起到避免输入错误数据的作用

获取属性值的getXxx方法和设置属性值的setXxx方法

puplic class Student {
    private String name;
    private int age;
    
    // Eclipse 自动生成的get和set方法，我好难，我还得手打
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
        System.out.println("你的名字有" + name.length() +"个字辣么长！");
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if(age >= 0 && age <= 150) {
            this.age = age;        
        } else {
            System.out.println("数值输入错误")
            this.age = 1;
        }
    }
    
    public void introduce() {
        System.out.println("大家好，我是" + name + "，我们遇到什么困难也不怕"
        + age + "勇敢的面对它，战胜困难的最好办法就是面对恐惧")
    }
}
 
public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("冬泳怪鸽")
        System.out.println("stu1的名字是" + stu1.getName());
        stu1.setAge(-10);
        stu1.intruduce();
    }
}

访问控制 private default 默认) protected public
同一类 ✓ ✓ ✓ ✓
同一包 ✗ ✓ ✓ ✓
字类 ✗ ✗ ✓ ✓
全局范围 ✗ ✗ ✗ ✓

3.3 构造方法

  1. 构造方法的定义

  2. 方法名与类名相同

  3. 方法名的前面没有返回值类型的声明

  4. 在方法中不能使用return语句返回一个值，但是可以单独写一个return语句作为方法的结束

    public class Person {
    public Person() {
    System.out.println("Person 的默认构造方法被调用了。")
    }
    }

    public static void main(String[] args) {
    Person p1 = new Person();
    System.out.println("END");
    }

    //Person 的默认构造方法被调用了。
    //END

注意：
Java的每个类都会至少有一个构造方法，即使不声明方法，系统也会自动创建一个默认的空构造方法

但是一旦声明方法后，系统默认创建的空方法就不会再生成了，此时想要调用空方法就需要用户自己声明一个空的方法。

  1. 构造方法的重载

方法名相同，但是每个方法的参数、方法类型的顺序不同

  1. 方法的个数不同
  2. 方法的类型不同
  3. 参数类型的顺序不同

3.4 this关键字

为了提高代码的可读性，同时避免变量的冲突，Java中引入了一个关键字this用于指代当前对象——用于在方法中访问其他成员

  1. this关键字可以明确指向成员变量，解决与局部变量的冲突，同时提高代码可读性

  2. 通过this关键字调用成员方法

  3. 可以在一个调用方法中使用 this([参数1, 参数2, ...])的形式来调用其他的方法

    class Person() {
    public Person() {
    System.out.println("无参方法被调用");
    }
    public Person (String name) {
    this();
    System.out.println("有参方法被调用")
    }
    }

    public class Example {
    public static void main (String[] args) {
    Person p = new Person ("itcast");
    }
    }

    // 在有参函数中调用无参函数
    // new的Person类中有函数
    // 调用有参数的方法
    // 有参的方法中有this, 于是指向无参的构造方法
    // 最后先输出无参，再输出有参，最后回到Example类

    //无参方法被调用
    //有参方法被调用

只能在构造方法中使用this调用其他的构造方法，不能在成员变量中使用
在构造方法中，使用this调用构造方法的语句 必须放在第一行，只能出现一次

可以在无参数的构造方法中调用有参数的构造方法
也可以在有参的构造方法中调用无参数的构造方法

3.5 垃圾回收

当一个对象成为垃圾后仍会占用内存，需要清理
对一个对象赋值为 NULL，就会使这个对象成为垃圾。因为当前对象所分配的空间不在被调用

Java虚拟机会进行自动垃圾回收，用户也可以通过 System.gc()方法 立即进行垃圾回收。当一个对象在内存中被释放时，finalize方法会被自动调用，可以使用 finalize() 方法来观察对象何时被释放

3.6 static 关键字

  1. 静态变量

static变量的数据单独存放在一块内存中并且供全局变量使用，一旦更改就会全局都更改

可以使用 类名.变量名 的形式访问static变量

static关键字只能修饰成员变量，不能修饰局部变量，否则会编译报错

  1. 静态方法

使方法不必和对象绑在一起

class Person {
    public static void sayHello() {
        System.out.println("Hello.");
    }
}
class Example {
    public static void main (String[] args) {
        Person.sayHello // 类名.方法 的方式调用静态方法
        Person p = new Person();
        p.sayHello();  // 实例化 对方 的方式调用静态方法
    }
}
  1. 静态代码块

使用一对大括号包围起来的若干行代码被称为一个代码块，被static修饰的叫静态代码块

static {
    System.out.println("静态代码块");
}

类被加载的时候，优先执行静态代码块，由于类只加载一次, 所以静态代码块只执行一次

  1. 成员内部类

允许在成员内部定义类

public class Outer {
    int num = 4;
    
    void print() {
       Inner in = new Inner();
       in.show();
    }
    
    class Inner() {
        int number = 6;
        void show() {
            System.out.println("Inner.number=" + number);
        }
    }
}
 
Outer out = new Outer();
out.println();
// 调用成员外部类Outer
// 外部类Outer 里面实例化了内部类Inner
// 通过内部类Inner 输出了结果
 
// Inner.number=6
 
Outer out = new Outer();
 
Outer.Inner in = new Out().New Inner();
// 调用内部类时
// 只能先访问外部类再访问内部类

第 4 章 面对对象(下)

4.1 类的继承

子类可以调用父类的方法
父类不能调用子类的方法

4.5 异常

  1. 异常

错误(error)
程序本身不能恢复执行

异常(exception)
程序本身可以处理的错误

String getMessage() //返回此 throwable 的详细信息字符串
void printStackTrace() //将此 throwable 及其追踪输出至标准错误流
void printStackTrace(PrintStream s) //将此 throwable 及其追踪到指定的输出流

  1. try...catch 和 finally

    try{
    // 可能会出错的代码
    } catch (ExceptionType(Exception 类 及 子类) e ) {
    }

try中写可能发生异常的代码，catch中写针对异常的信息

catch需要一个接收的异常类型，这个参数必须是Exception 或子类

try {
    int result = divide(4, 0);
    System.out.println("结果是：" + result);
} catch (Exception e) {
//  System.out.println("捕获到的异常：" + e.getMessage());
    e.printStackTrace;
//  System.exit(0); //退出程序, 无异常退出，正常退出
//  除了exit方法可以终止finally的运行，其他函数均无法终止finally的运行
    return; // 退出所在方法
} finally {
    System.out.println("finally模块");
}
 
System.out.println("程序继续运行");
 
public static int divide(int i, int j) {
    int result = i / j;
    return result;
}

在try代码块中发生异常的语句后面的代码是不会运行的

  1. throws 关键字

    public static int dicide(int i, int j) throws Exception {
    int result = i / j;
    return result;
    }

  2. 自定义异常

    public class DivideByMinusException extends Exception {
    public DicideByMinusException() {
    super();
    }

    		 public DicideByMinusException(String msg) {
    		     super(msg); // message
    		 }

    }

    public static int divide(int i, int j) {
    if(j < 0) {
    // DicideByMinusException DBME = new DicideByMinusException();
    // throw DBME;
    throw new DicideByMinusException();
    // 只有继承 异常 才能 throw，否则

    		 } else {
    		     int result = i / j;
    		     return result;
    		 }

    }

posted @   鲲特牌  阅读(395)  评论(4)  编辑  收藏  举报
编辑推荐：
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
点击右上角即可分享
微信分享提示