java学习笔记

Java学习笔记

引入

问：是谁第一个公司发明图形化界面呢？
答：施乐

因为加载速度慢和加载图片占内存的缘故，引入了CMD命令行。

一些特殊键

Win+E 打开我的电脑
shift+箭头选择需要的行 + Ctrl+/ 进行注释
Ctrl+Z 撤回
Ctrl+S 保存

cmd命令

序号	命令	作用
1	Win+R 输入cmd	打开运行窗口
2	盘符名称+冒号	切换到指定目录
3	dir	查看当前路径下的所有内容
4	cd 目录	进入单级目录
5	cd..	回退
6	cd 目录1\目录2...	进入多级目录
7	cls	清屏
8	exit	退出命令提示符窗口
9	cd\	回退到盘符目录

如何配置环境变量

针对Windows10和Windows11，打开控制面板，搜索环境变量，找到编辑账户的环境变量，在找到对应程序所处的路径中，比如QQ在D:\QQNT，就把该条路径通过新建并确定后，再次打开运行窗口，输入QQ.exe即可打开。

Java 基础注意事项

javac 编译
java 载入字节码文件
一个java类型的文件名要与类名一致
常见拓展名
.java 源文件
.class 字节码文件

输入输出

public class Hello{
    public static void main(String[]args){
        System.out.println("Hello World");
        Scanner in=new Scanner(System.in);
        System.out.println("echo:"+in.nextline());//**in.nextline是把下一行都进来** **＋号可以把没有在双引号内的内容变成字符串与前面的字符串一起输出**
        System.out.println("2+3="+(2+3));//输出为2+3=5
        System.out.println("2+3="+2+3);//输出为2+3=23
    }
}

System.out.println();//换行输出
System.out.print("aaa");//不换行输出

变量

变量的写法和C语言的写法是一样的
例如：

int price =0;
price=in.nextInt();
double t;
t=in.nextDouble;

常量

final int amount=100;
定义了一个常量amount，无法再在接下来的操作中赋值。

scanner 类的使用

scanner a=new scanner(System.in);
System.out.println(a.next());
System.out.println(a.nextInt());
System.out.println(a.nextDouble());
System.out.println(a.nextLine());
while(a.hasNextInt()){
    int x=a.nextInt();
    int y=a.nextInt();
    System.out.println(x+y);
}

next,读入一个标记，标记之间可以以空格，多个空格或者回车进行分隔。
nextInt、nextDouble 相应类型转换
nextLine,读入一行
hasNext,判断是否还有其他标记

string 类

public String substring(int beginIndex);
public String substring(int beginIndex,int endIndex);

例如：

public class SubstringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // 从索引6开始截取到字符串末尾，输出 "World!"
        System.out.println(str.substring(6)); 
        
        // 从索引0开始截取到索引5（不包含），输出 "Hello"
        System.out.println(str.substring(0, 5)); 
        
        // 截取从索引7到索引11（不包含）的字符，输出 "World"
        System.out.println(str.substring(7, 12)); 
    }
}

字符串转基本类型

public class Test{
    public static void main(String[] args){
        String x='10';
        double y=Double.parseDouble(x);
        System.out.println(y);//结果为2.0
        int p=Integer.parseInt(x,2);//将x转化为2进制，并赋值给p
        System.out.println(p);//结果为2

    }
}

比较

System.out.print(amount>=10);
如果成立则输出true，反之false
浮点数存在一定误差。例如a=1.0与b=0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1，a与b不相等，因为b得出来的结果只会无限接近于1

Math.abs(f1-f2)<0.00001 用于判断两个浮点数是否相等

选择结构

流程图

圆角矩形表示开始
方框表示要去做什么
平行四边形输入
菱形 作比较

选择结构-if语句（同c语言相同）

if(判断条件){
    执行语句
}

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

判断条件？表达式1：表达式2

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

选择结构-switch语句(同C语言相同)

switch（表达式）{
    case 目标值1：
    执行语句1;
    break;
    case 目标值n:
    执行语句n;
    break;
    default:
    执行语句n+1;
    break;
}

循环结构

循环结构-while语句(同C语言相同)

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

循环结构-do while语句(同C语言相同)

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

for循环，break跳出语句（跳出循环，不再参与下一次循环）也是同C语言相同，故不再列出，continue语句的作用是终止本次循环，执行下一次循环。

循环结构-forEach语法

for(String e:arrList){
System.out,println(e);
}

方法

方法的语法格式

在Java中，声明一个方法的具体语法格式

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

（个人觉得Java的方法和C语言的函数好像）

方法的重载

Java中允许在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载，Java会根据传递过来的参数自动匹配类型。

数组

数组的定义

int[]x=new int[100];
//或者可以拆分为两行来写
int[]x;
x=new int[100];

数组的长度

数组名.length

数组的初始化

数据类型	默认初始化值
byte、short、int、long	0
float、double	0.0
char	一个空字符，即'\u0000'
boolean	false
引用数据类型	null,表示变量不引用任何对象

静态初始化

1.类型[] 数组名=new 类型[]{元素,元素,......};//注意，此处[]内不加数组个数

2.类型[] 数组名={元素，元素，元素......};

数组的遍历和排序和C语言相同，故不再记述。

多维数组

二维数组的定义：

方法一：

int[][]xx=new int[2][3];//两行三列的数组

方法二：

int[][]xx=new int[2][];//表示里面有两组数组，不过数组中每个元素的长度不确定。

arr.length是整个多维数组的长度，arr[i].length是第i组元素组的长度.
方法三：

int[][]xx={{1,2},{3,4,5,6},{7,8,9}};

ArrayList

具有自动调节容量的功能，但是不能添加基本类型数据

List<String>stList3=new ArrayList<>();

1.arrList.size();//获得长度
2.arrList.get(i);//获得第i个元素
3.arrLIst.add("xxx");//添加
4.arrList.remove(i);//移除第i个元素
5.String[]strs=list.toArray(new String[0]);//将列表中的元素放入数组strs

面向对象

用类制造对象

对象是实体，需要被创建，可以为我们做事情
类是规范，根据类的定义来创造对象
类定义了对象，而每一个对象都是类的实体
对象=属性+服务 ，人们通过操作来操控数据，数据是核心，当把数据和对数据的操作放在一起时->封装

定义类

有什么来组成这个场景，这个场景里面的东西又能够给我们提供什么服务（面向对象的方式）
例如：自动贩卖机
属性

price
balance
total

动作

show prompt
insert money
get food

以下是通过AI写出来的程序

public class VendingMachine {
    // 商品价格
    private double price;
    // 投币后当前余额（用于判断是否够买商品）
    private double balance;
    // 贩卖机总收入
    private double total; 

    // 构造方法，初始化商品价格
    public VendingMachine(double price) {
        this.price = price;
        this.balance = 0;
        this.total = 0;
    }

    // 显示提示信息，告知商品价格等
    public void showPrompt() {
        System.out.println("欢迎使用自动贩卖机！商品价格为：" + price + " 元");
        System.out.println("当前已投币余额：" + balance + " 元");
    }

    // 投币动作，增加余额和总收入
    public void insertMoney(double money) {
        if (money > 0) {
            balance += money;
            total += money;
            System.out.println("已投币：" + money + " 元，当前余额：" + balance + " 元");
        } else {
            System.out.println("投币金额不能小于等于 0，请重新投币！");
        }
    }

    // 取餐动作，判断余额是否足够，够则扣钱并提示取餐，不够则提示
    public void getFood() {
        if (balance >= price) {
            balance -= price;
            System.out.println("已扣除 " + price + " 元，当前余额：" + balance + " 元");
            System.out.println("请取走您的商品，欢迎再次使用！");
        } else {
            System.out.println("余额不足，请继续投币！");
        }
    }

    // 主方法测试
    public static void main(String[] args) {
        // 创建自动贩卖机实例，假设商品价格为 5 元
        VendingMachine vm = new VendingMachine(5); 
        vm.showPrompt();

        vm.insertMoney(3);
        vm.showPrompt();

        vm.insertMoney(3);
        vm.showPrompt();

        vm.getFood();
        vm.showPrompt();
    }
}

成员变量和成员函数

每一次调用都会建立起对象和函数的联系

通过.运算符调用某个对象的函数
在成员函数内部直接调用自己（this）的其他函数
而在成员函数的外部需要通过对象的名字去调用成员函数
定义在函数内部的变量是本地变量（生存期在和作用域都在函数内部），定义在外部是成员变量（成员变量的生存期是对象的生存期，作用域是类内部的成员函数）。

对象的初始化

如果本地变量没有初始化，那么会出现问题，但成员变量没有初始化，需要另外讲，是因为后续new一个新对象后，会给成员变量默认的零值。
创建一个与类名相同的函数为构造函数构造的时候会被自动调用，该函数没有返回类型。
函数重载
1.一个类可以有多个构造函数，只要他们的参数表不同
2.创建对象的时候给出不同的参数值，就会自动调用不同的构造函数
3.通过this()还可以调用其他构造函数
4.一个类里的同名但参数表不同的参数构成了重载关系

对象的识别

例如：时钟的程序

value
limit

increase
getvalue

对象的交互

通过 Display 类封装计数逻辑，Clock 类组合 Display 对象（hour 和 minute）来模拟时钟的小时和分钟计数，是典型的面向对象设计（组合模式）：
以下为AI辅助生成：

public class Display {

    private int value = 0;
    private int limit = 0;

    public Display(int limit) {
        this.limit = limit;
    }

    public void increase() {
        this.value++;
        if (value == limit) {
            value = 0;
        }
    }

    public int getvalue() {
        return value;
    }

    public static void main(String[] args) {

        Display d = new Display(24);
        for (int i = 0; i < 120; i++) {
            d.increase();
            System.out.println(d.getvalue());
        }

    }
}

public class Clock {
    private Display hour = new Display(24);
    private Display minute = new Display(60);

    public void start() {
        for (int i = 0; i < 120; i++) {
            minute.increase();
            if (minute.getvalue() == 0) {
                hour.increase();
            }
            System.out.printf("%02d:%02d", hour.getvalue(), minute.getvalue());
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Clock clock = new Clock();
        clock.start();
    }

}

封闭的访问属性

private 私有的，private只能用在成员函数或者成员变量，只有两个地方能够使用成员变量：

自己的类里面
通过已有的成员变量来初始化
...

参考资料：
1.https://www.bilibili.com/video/BV1wL411L7A3/?spm_id_from=333.1391.0.0&p=59

2.https://mooc1-1.chaoxing.com/mooc-ans/visit/stucoursemiddle?courseid=254072888&clazzid=124799117&vc=1&cpi=433296807&ismooc2=1&v=2

(完)

posted @ 2025-08-06 22:07 才知风自由阅读(24) 评论(0) 收藏举报

刷新页面返回顶部

Chensy

java学习笔记