JAVA学习笔记（上）

已于 2022-09-30 15:32:30 修改
阅读量207 收藏
点赞数
分类专栏： JAVA 文章标签： 学习 java
于 2022-07-19 20:27:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66967137/article/details/125483608
版权

目录

基础知识

Java概述

变量

运算符

控制结构

数组

面向对象基础

方法

方法重载

基础知识练习

099类和对象

补充：Java内存分配介绍

107private

109this

111封装

112构造方法

114标准类JavaBean

115API

117String

127StringBuilder

134ArrayList

140——149学生管理系统

基础知识

Java概述

001JAVA语言发展史

  • 1995 Sun公司
  • JAVA之父——詹姆斯高斯林

002JAVA语言跨平台原理

  • JVM（Java Virsual Machine）充当各个平台（Windows MacOS Linux）的翻译

003JRE和JDK

  • JRE(Java Runtime Environment):Java程序运行环境，包含JVM和运行时所需要的核心类库
  • JDK(Java Development Kit):java程序开发工具包，包含JRE和开发人员使用的开发工具——编译工具（javac.exe）和运行工具（java.exe）

JDK、JRE、JVM的关系

83f6eae42355420b854b4f91523e5ee3.png

 004JDK的下载和安装

005常用DOS命令

操作说明
盘符名称：切换盘符 如D：
dir查看当前目录下的内容

cd 目录

进入单级目录
cd ..回退到上一集目录
cd 目录1\目录2\......进入多级目录
cd \回退到盘符目录
cls

清屏

exit退出命令提示符窗口

006Path环境变量的配置

为什么要配置Path环境变量？

  • 开发JAVA程序，需要使用JDK提供的开发工具，而这些工具在JDK安装目录的bin目录下。
  • 为了在开发JAVA程序的时候，能够方便地使用javac和java命令，我们需要配置Path环境变量

如何配置

007HelloWorld案例

d195d005b4784f2db5497d382542c73d.png

  • 记事本编写HelloWorld.java文本文件——Java源程序 
  • 编译javac HelloWorld.java
  • 运行java HelloWorld
  • 生成HelloWorld.class——Java字节码文件

008HelloWorld常见问题

BUG的解决

  • 具备识别BUG能力（多看）
  • 具备分析BUG能力（多思考，多查阅资料）
  • 具备解决BUG能力（多尝试、多总结）

ex:

  • 非法字符——中文输入状态输入字符——中英文符号问题
  • 程序包system不存在——大小写错误S——单词拼写问题

009Notepad软件的安装和使用

方便代码编写和修改

也可使用Eclipse idea等代码编辑器

010注释

  • //单行注释
  • /*多行注释*/
  • /**文档注释*/

tips可以在代码中用注释做笔记

变量

011关键字

  • 关键字字母全部小写
  • 常用代码编辑器有颜色标记

012常量

常量类型距举例
字符串常量"HelloWorld"
整数常量666        -88
小数常量13.14        -5.21
字符常量'A'        '0'        '我'
布尔常量只有两个：true false
空常量一个特殊的空值：null

注意，空常量不能直接输出

013数据类型

计算机存储设备的最小信息单元叫”位（bit）“，也称”比特位“，通常用小写字母b表示

计算机中最小的存储单元叫”字节（byte）“，通常用大写字母B表示。（字节由连续8个位组成）

  • 1B=8bit
  • 1KB=1024B
  • 1MB=1024KB
  • 1GB=1024MB
  • 1TB=1024GB

2e2c1da0340f43599b9c66062de23886.png

  • bd7a6663b77d48b6a369bec05dab1cd7.png

014变量

本质上讲，变量是内存中一小块区域

和C语言一样 

  • 定义格式：int a=10;
  • 取值格式：a
  • 修改值格式：a=20;

015变量使用的注意事项 

b4ad6ba3c4f84eb0b80cfd25ca359692.png

9f16a47a633f4fcda13b68e760fa27ef.png

  • 定义long型变量时防止整数太大需要加上L： long n = 1000000000L
  • 定义float型变量时为了防止不兼容的类型要加F：float f = 13.14F

016标识符

定义规则

  • 由数字、字母、下划线和美元符组成
  • 不能以数字开头
  • 不能是关键字
  • 区分大小写

 常见命名约定

小驼峰命名法(方法、变量)大驼峰命名法（类）
标识符是一个单词nameName
标识符由多个单词组成firstNameFirstName

017类型转换

自动类型转换

94e2dbb483194aaa868f076d10e314f0.png

强制类型转换

  • 同C语言：int k=(int)88.88;
  • 慎用，因为会有数据精度丢失

运算符

018算数运算符

+        -        *        %

同C

019字符的+操作

  • 同C：字符的ASCII码相加
  • 算数表达式包含多个基本数据类型的值时，整个算术表达式的类型会自动提升到表达式中的最高等级

020 字符串的+操作

5f7858d174be45d8ad181daf12b507dd.png

 021赋值运算符

ad1ea30e6557451cac66b5c424ffd315.png

4648c0ccf46c413c90a40715a2b6d70f.png

注意，i = i  + 10与 i += 10并不等价，因为 i += 10隐含了强制类型转换

022自增自减运算符

同C

  • 单独使用：i++;与++i效果等价
  • 参与操作：int k=i++;与int k=++i;不同

023关系运算符

  • a==b         a!=b        a>b        a>=b     
  • 上述关系表达式的值一定为布尔类型

注意：不要将==写成=！！！

024逻辑运算符

连接关系表达式或者连接布尔类型的常量或变量

符号作用说明
&逻辑与a&b        a,b同真才为真 (有false则false)
|逻辑或a|b        a,b同假才为假 (有true则为true)
^逻辑异或a^b        a,b相同为false，不同为true
!逻辑非!a        奇变偶不变(奇数个!变为相反，偶数个不变)

 025短路逻辑运算符

233b73a74727436c94efc44c7a4ddcf3.png  例如

public class Main{
    public static void main(String[] args){
        int i=10,j=20;
        //System.out.println((i++ > 100) & (j++ > 100));//false & false
        System.out.println((i++ > 100) && (j++ > 100));//false && false
        System.out.println("i:"+i);//i=11
        System.out.println("j:"+j);//j=21
    }
}

3c3113e2ea2a4453937f65b2424ad05b.png

原因： (i++ > 100) && (j++ > 100)中第一个表达式为假，&&后边的表达式就不会执行了，这就是所谓短路

其中， System.out.println()：调用系统类 System 中的标准输出对象 out 中的方法 println()

026三元运算符

格式：关系表达式？表达式1：表达式2

范例：a > b ? a : b

计算规则：

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

补充：原码、反码、补码

计算数字的逻辑与逻辑或没有短路的

 200的补码左移两次，右边空了两位（所以是低位补0），左边出去了的两位弃之，现在的补码转成十进制就是800.

公式： 左移一次，就是乘2；左移两次，就是乘4；

200的补码右移两次，左边空了两位（高位补0或1：数值位补0，符号位补与原来的数字相同的符号位），右边出去了的两位弃之，现在的补码转成十进制就是50.

公式： 右移一次，就是除2；右移两次次，就是除4；

补充：计算机中的数据存储

 

 

027两只老虎

注意代码规范

91023b21ab3c4e4a86d5e857ed9af554.png 028三个和尚

同上

029数据输入

b6c3c1954e90476babda7649fe1f854d.png

/*
    数据输入：
        导包：
            import java.util.Scanner;
        创建对象：
            Scanner sc = new Scanner(System.in);
        接收数据：
            int x = sc.nextInt();
*/
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        //创建对象：
            Scanner sc = new Scanner(System.in);
        //接收数据：
            int x = sc.nextInt();
        //输出数据
        System.out.println("x:"+x);
    }
}

030三个和尚升级版

控制结构

031顺序结构

032if结构

033if......else

034判断奇偶数

035if...else if...else结构

036按考试成绩给奖励

037switch结构

038春夏秋冬

039for结构

040输出数据

041求和

042求偶数和

043水仙花

044统计

045while结构

046珠穆朗玛峰

047 do...while结构

048三种循环的区别

049跳转控制语句

050循环嵌套

051Random

 ex1:

ex2: 

/*
		Random

	    作用：
			产生一个随机数

		使用步骤：
			导包：
				import java.util.Random;
			创建对象：
				Random r = new Random();
			获取随机数：
				int number = r.nextInt(10);
				获取数据的范围：[0，10) 包括0，不包括10
*/
import java.util.Random;
public class Demo{
    public static void main(String[] args){
        //创建对象：
		Random r = new Random();
		for(int i=0;i<10;i++){
			//获取随机数：
			int number = r.nextInt(10);
			//输出数据
			System.out.println("number:"+number);
		}
    }
}

 

052猜数字

/*
	猜数字
	    需求：
			程序自动产生一个1—100之间的数字，使用程序实现才出这个数字是多少？
			当猜错时根据情况给出提示
*/
import java.util.Random;
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //创建对象 获取随机数：
		Random r = new Random();
		int number = r.nextInt(100)+1;
		while(true){
			//创建对象接收输入的猜测数字
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数字：");
			int guessNumber = sc.nextInt();
			//比较输入的数字和系统产生的随机数，使用分支语句输出提示信息
			if(guessNumber>number){
				System.out.println("你猜的数字"+guessNumber+"大了:");
			}else if(guessNumber<number){
				System.out.println("你猜的数字"+guessNumber+"小了:");
			}else{
				System.out.println("恭喜你猜中了！");
				break;
			}
		}
    }
}

053IDEA安装

IDEA全称IntelliJ IDEA,是用于JAVA语言开发的集成环境，业界公认的目前用于Java程序开发最好的工具

集成环境：把代码编写，编译，执行，调试等多种功能综合到一起的开发工具

055——057使用IDEA

数组

058数组定义格式

最好使用格式一 

059数组的动态初始化

 060数组元素访问

同C

061内存分配

  

062单个数组内存图

063多个数组内存图

064多个数组指向相同内存图

065数组静态初始化

  • int[] arr = new int[]{ 1, 2, 3 };
  • 简化格式：int[] arr = { 1, 2, 3  }; 注意开辟空间(即new这个动作)还是有的

066数组操作的常见问题

  • 索引越界
    • 例如 
      int[] arr = new int[3];
      System.out.println(arr[3]); 
  •  空指针异常

067遍历 

  •  如果只是遍历数组，不修改对应的值，可以使用增强for
  • 获取数组元素数量：
    • 格式：数组名.length
    • 范例：arr.length

068获取最值

面向对象基础

方法

069方法概述

 

070方法的定义和调用 

 071方法调用过程图解

和C语言里调用函数过程一致

072方法练习

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

和c语言一致

074形参和实参

075带参数的方法练习

076带返回值方法定义和调用

077带返回值方法练习

078方法的注意事项

  • 方法不能嵌套定义

079方法的通用格式

定义方法时，要做到两个明确：

  • 明确返回值类型：主要是明确方法调用完毕之后是否有数据返回
  • 明确参数：主要是明确参数的类型和数量

 调用方法时：

  • void类型的方法，直接调用即可
  • 非void类型的方法，推荐用变量直接接收调用

方法重载

080方法重载

  •  方法重载概述：
    • 指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法构成重载
      • 多个方法在同一个类中
      • 多个方法具有相同的方法名
      • 多个方法的参数不相同，类型不同或者数量不同
  • 方法重载特点：
    • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
    • 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关（即不能通过返回值判定两个方法是否相互构成重载） 

 081方法重载练习

082方法参数传递基本类型

083方法参数传递引用类型

 

084数组遍历

public class printArray {
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55};
        printArray(arr);
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }
            else{
                System.out.print(arr[i]+",");
            }
            //System.out.print(arr[i]+",");
        }
        System.out.print("]");
    }
}

085数组最大值

public class ArrayMax {
    public static void main(String[] args) {
        int[] arr={11,22,33,44,55};
        int result=ArrayMax(arr);
        System.out.println("maxValue of array is:"+result);
    }
    public static int ArrayMax(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
}

086Debug

  • Debug概述：是供程序员使用的调试工具，可用于查看程序的执行流程，也可用于追踪程序执行过程来调试程序
  • Debug调试：又称断点调试，断点即一个告诉我们从哪里开始看的标记
  • Debug操作流程：
    • 如何加断点
    • 如何运行加了断点的程序
    • 看哪里
    • 点哪里
    • 如何删除断点 

087Debug查看偶数求和

/*查看循环求偶数和的执行流程*/
public class DebugTest01 {
    public static void main(String[] args) {
        //定义求和变量
        int sum = 0;
        //循环求偶数和
        for(int i = 1; i <= 10; i++){
            if(i%2==0){
                sum += i;
            }
        }
        //输出结果
        System.out.println("1-10之间的偶数和是："+sum);
    }
}

088Debug查看方法调用

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

        //接收数据
        System.out.println("请输入第一个整数：");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int b = sc.nextInt();

        //调用方法
        int max = getMax(a,b);

        //输出结果
        System.out.println("较大的值是："+max);
    }
    //获取两个数的较大值
    public static int getMax(int a, int b){
        if(a>b){
            return a;
        }else{
            return b;
        }
    }
}

注意：如果数据来自于键盘输入，一定要记住输入数据，不然就不能继续往下查看了 

基础知识练习

089减肥计划if版

package BasicPractice;
import java.util.Scanner;
/*
*   需求：输入星期数，显示今天的减肥活动
*   思路：
*       1.键盘输入一个星期数，用一个变量来接收
*       2.对星期进行判断，这里用if语句实现
*       3.在对应语句控制中输出对应的减肥活动
* */
public class LoseWeight_if {
    public static void main(String[] args) {
        //1.键盘输入一个星期数，用一个变量来接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();
        //2.对星期进行判断，这里用if语句实现
        if(week<1 || week>7){
            System.out.println("你输入的星期数有误");
        }else 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("好好吃一顿");
        }
    }
}

090减肥计划switch版

package BasicPractice;
import java.util.Scanner;
/*
 *   需求：输入星期数，显示今天的减肥活动
 *   思路：
 *       1.键盘输入一个星期数，用一个变量来接收
 *       2.对星期进行判断，这里用switch语句实现
 *       3.在对应语句控制中输出对应的减肥活动
 *   导包:
 *       1.手动导包：import java.util.Scanner;
 *       2.快捷键导包:Alt+Enter
 *       3.自动导包
 * */
public class LoseWeight_switch {
    public static void main(String[] args) {
        //1.键盘输入一个星期数，用一个变量来接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();
        //2.对星期进行判断，这里用switch语句实现
        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("你输入的星期错误");
        }
    }
}

091逢七过

package BasicPractice;
/*
*   需求：
*       朋友聚会时可能会玩过一个游戏：逢7过。
*       规则是，从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。
*       为了帮助大家更好地玩这个游戏，这里我们直接在控制台打印出1——100之间的满足逢7必过规则的数据。
*       这样，大家将来在玩儿游戏的时候，就知道哪些数据要说：过。
*   思路：
*       1.数据在1——100之间，用for循环实现数据的获取
*       2.根据规则，用if语句实现数据的判断，要么个位是7，要么十位是7，要么能够被7整除
*       3.在控制台输出满足规则的数据
* */
public class Meet7Pass {
    public static void main(String[] args) {
        //1.数据在1——100之间，用for循环实现数据的获取
        for(int x=1;x<=100;x++){
            //2.用if语句实现数据的判断，要么个位是7，要么十位是7，要么能够被7整除
            if(x%10==7 || x/10%10==7 || x%7==0){
                System.out.println(x);
            }
        }
    }
}

092不死神兔

package BasicPractice;
/*
*   需求：
*       有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
*       假如兔子都不死，问第12个月的兔子对数是多少？
*   思路：
*       1.为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
*       2.因为第1个月，第2个月的兔子对数是已知的，都是1，所以数组的第一个元素和第二个元素都是1
*       3.用循环实现计算每个月的兔子对数
*       4.输出数组中最后一个元素的值，就是第20个月的兔子对数
*
* */
public class MagicRabbit {
    public static void main(String[] args) {
        //1.为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        int[] arr = new int[20];
        //2.因为第1个月，第2个月的兔子对数是已知的，都是1，所以数组的第一个元素和第二个元素都是1
        arr[0]=1;
        arr[1]=1;
        //3.用循环实现计算每个月的兔子对数
        int i;
        for(i=2;i<arr.length;i++){
            arr[i]=arr[i-1]+arr[i-2];
        }
        //4.输出数组中最后一个元素的值，就是第20个月的兔子对数
        System.out.println("第20个月的兔子对数:"+arr[i-1]);
    }
}

093百钱百鸡 

package BasicPractice;
/*
*   需求：
*       我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
*       百钱买百鸡，问鸡翁，鸡母，鸡雏各几何？
*   思路：
*       1.第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0,判断条件是x<=20
*       2.第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0,判断条件是y<=33
*       3.这个时候，用于表示鸡雏的变量z = 100 - x - y
*       4.判断表达式 z%3==0 和表达式 5*x + 3*y +z/3 = 100是否同时成立，如果成立，输出对应的x,y,z的值，
*         就是对应鸡翁，鸡母，鸡雏的值
*
* */
public class LimitedMoneyToChicken {
    public static void main(String[] args) {
        //1.第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0,判断条件是x<=20
        for(int x=0;x<=20;x++){
            //2.第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0,判断条件是y<=33
            for(int y=0;y<=33;y++){
                //3.这个时候，用于表示鸡雏的变量z = 100 - x - y
                int z = 100 - x - y;
                //判断表达式 z%3==0 和表达式 5*x + 3*y +z/3 = 100是否同时成立
                if(z%3==0 && 5*x+3*y+z/3==100){
                    System.out.println(x+","+y+","+z);
                }
            }
        }
    }
}

 094特定数组元素求和

package BasicPractice;

public class SpecificArrSum {
    public static void main(String[] args) {
        int[] arr = new int[]{68,27,95,88,171,996,51,210};
        int sum = 0;
        for(int x=0;x<arr.length;x++){
            if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0){
                sum=sum+arr[x];
            }
        }
        System.out.println(sum);
    }
}

095比较数组内容相同

package BasicPractice;

public class ArrCompare {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr = {11,22,33,44,55,66};
        int[] arr2 = {11,22,33,44,55,66};
        //定义一个变量接收方法调用结果
        boolean result=compare(arr,arr2);
        System.out.println("两个数组相同吗？"+result);
    }
    //定义一个方法，用于比较两个数组的内容是否相同
    /*
    *   两个明确：
    *       返回值类型：boolean
    *       参数：int[] arr ,int[] arr2
    * */
    public static boolean compare(int[] arr ,int[] arr2){
        //首先比较数组长度，如果长度不相同，数组内容肯定不同，返回false
        if(arr.length!=arr2.length){
            return false;
        }
        //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
        for(int i=0;i<arr.length;i++){
            if(arr[i]!=arr2[i]){
                return false;
            }
        }
        //最后循环遍历结束后，返回true
        return true;
    }
}

096查找数据索引

097数组反转

package BasicPractice;

public class ArrInversion {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19,28,37,46,50};
        //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
            //变量交换
            int temp =arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }
        //遍历数组
        printArray(arr);
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else {
                System.out.print(arr[i]);
            }
        }
        System.out.print("]");
    }
}

098评委打分

package BasicPractice;

import java.util.Scanner;

public class Judges_scoring {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成完成对数组元素的初始化，长度为6
        int[] arr = new int[6];
        //键盘录入6个评委所打分数
        Scanner sc = new Scanner(System.in);
        for(int x=0;x<6;x++){
            System.out.println("请输入第"+(x+1)+"个评委的打分：");
            arr[x]=sc.nextInt();
        }
        //printArray(arr);
        //调用实现获取数组中的最高分的方法
        int max=getMax(arr);
        //定义方法实现获取数组中的最低分
        int min=getMin(arr);
        //定义方法实现数组中所有元素的和，调用方法
        int sum=getSum(arr);
        //按照计算规则计算所得平均分
        int avg = (sum - max -min)/(arr.length-2);//不直接写4方便后续修改维护
        //输出平均分
        System.out.println("选手最终的得分是"+avg);
    }
    //遍历数组
    public static void printArray(int[] arr){
        System.out.print("[");
        for(int i=0;i<arr.length;i++){
            if(i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else {
                System.out.print(arr[i]);
            }
        }
        System.out.print("]");
    }
    /*
    *   两个明确：
    *       返回值类型：int
    *       参数：int[] arr
    * */
    //实现获取数组中的最高分
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
    //定义方法实现获取数组中的最低分
    public static int getMin(int[] arr){
        int min = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]<min){
                min=arr[i];
            }
        }
        return min;
    }
    public static int getSum(int[] arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum=sum+arr[i];
        }
        return sum;
    }
}

099类和对象

  • 什么是对象？
    • 万物皆对象客观存在的事物皆为对象
  • 什么是面向对象
    • 人关注对象（事物信息） 
  • 什么是类 
    • 类是对现实生活中一类具有共同属性和行为的事物的抽象
    • 类的特点
      • 类是对象的数据类型
      • 类是具有相同属性和行为的一组对象的集合
  • 什么是对象的属性
    • 属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值 
  • 什么是对象的行为
    • 行为：对象能够执行的操作

100类的定义

  • 类的重要性：是Java程序的基本组成单位
  • 类的组成：属性和行为
    • 属性：在类中通过成员变量来体现（类中方法外的变量）
    • 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
package MyPackage;
/*
*   类的定义
*
*   类的定义步骤：
*       定义类
*       编写类的成员变量
*       编写类的成员方法
*
*   手机类
*       类名：
*           手机（phone）
*       成员变量：
*           品牌（brand）
*           价格（price）
*       成员方法：
*           打电话（call）
*           发短信（sendmassage）
* */
public class Phone {
    //成员变量
    String brand;
    int price;

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

101对象的使用

package MyPackage;
/*
*   创建对象
*       格式：类名 对象名 = new 类名()；
*       范例：Phone p = new Phone();
*
*   使用对象
*       1.使用成员变量
*           格式：对象名.变量名
*           范例：p.brand
*       2.使用成员方法
*           格式：对象名.方法名()
*           范例：p.call()
* */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand="小米";
        p.price=2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendmassage();
    }
}

102学生

package MyPackage3;
/*学生类*/
public class Student {
    //成员变量
    String name;
    int age;
    //成员方法
    public void study(){
        System.out.println("努力学习，天天向上");
    }
    public void doHomework(){
        System.out.println("认真完成作业");
    }
}

package MyPackage3;
/*学生测试类*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用对象
        System.out.println(s.name+","+s.age);
        s.name="王祖贤";
        s.age=22;
        System.out.println(s.name+","+s.age);
        s.study();
        s.doHomework();
    }
}

补充：Java内存分配介绍

当运行一个类时，这个类的字节码文件（.class）就会被加载到方法区中临时存储。JDK7以前，方法区与堆空间是连在一起的，在真实的物理空间当中也是一片连续的空间。JDK8之后加载字节码文件就归属元空间了 

 Step1:把StudentTest.class字节码文件加载到方法区里面，这里面就会把main方法进行临时存储，然后虚拟机会自动地调用程序的主入口main方法，此时main方法会被加载到栈内存，然后开始执行main方法里的第一句代码——创建对象

 Step2:创建对象这句代码，虚拟机至少做了7件事（图片右上角）

  1. 加载class文件：在方法区里加载student.class临时存储
  2. 申明局部变量：即创建对象等号左边的代码——>在main方法中开辟一个空间，空间名字叫s，这个空间以后能存储Student这个类对象的地址值

    3. 在堆内存开辟一个空间：即创建对象等号右边的代码——>有new一定是在堆里开辟了一片空间，这个空间地址值假设是001，那么空间里面就会把student类里面所有的成员变量都拷贝一份，除此之外还会有所有成员方法的地址，存储方法的地址是为了以后用对象调用方法的时候我们能找到对应的方法。此时堆里001这个空间就是我们平时所说的对象，但是现在这个对象还没有创建完毕，因为这里的name，age还没有赋值。

     4.默认初始化：这里的name，age默认初始化值分别为null，0 

    5.显式初始化： 如果我们在代码中定义成员变量时是直接给值，比如name="张三"，age=23,那么这就叫显式初始化 。这个时候，之前默认初始化的地方就会被"张三"，23所覆盖。本例中没有显式初始化，则跳过这一步。

    6.构造方法初始化： 此处小括号里什么都没有，说明调用的是空参构造，而空参构造里也没有写代码，所以构造方法初始化也可以忽略。但如果是用的有参构造创建对象，那么现在name和age就会有值了。——构造方法是创建对象中的一步！

7. 把堆内存中的地址值赋值给左边的局部变量：即把此处的001通过中间的等号运算符赋值给左边的变量s，那此时s空间里就会存储地址值001，而s也可以通过001这个地址值找到右边的空间

 经过以上这7步，才可以说对象创建完毕。

 Step3:打印s的值，打印的其实是变量s记录的地址值001

Step4:通过s调用name和age ——>通过001这个地址值找到堆空间里的name值null和age值0并打印

 Step5:通过s调用name和age——>通过001这个地址值找到堆空间里的name和age，用"阿强"和23覆盖掉原来的null和0

 Step6:再次通过s调用name和age ——>通过001这个地址值找到堆空间里的name值和age值并打印，这次就是"阿强"和23了

Step7： 通过s找到001这个空间，这个空间里有成员方法的地址，通过该地址找到下面的study()方法，然后study方法被加载进栈。study()方法里代码打印完成之后，study()方法执行完毕，出栈；然后整个main方法也执行完毕，出栈。而main方法里的变量也会消失，对应堆内存里的空间就没用了就会被当作垃圾回收

答案是：不需要再加载一次字节码文件 

 当stu1从001改为null之后，它就无法找到对应地址去调用name方法了

补充：基本数据类型和引用数据类型的区别

103单个对象

104多个对象

105多个对象指向相同

106成员变量和局部变量

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

107private

package MyPackage4;
/*学生类*/
public class Student {
    //成员变量
    String name;
    int age;
    //成员方法
    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage4;
/*学生测试类*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name="林青霞";
        s.age=30;
        //调用show方法
        s.show();
    }
}
  • private关键字：是一个权限修饰符，可以修饰成员（成员变量和成员方法）
  • 作用：保护成员不被别的类使用，被private修饰的成员只在本类中才能访问（封装）
  • 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
    • 提供”get变量名()“方法，用于获取成员变量的值，方法用public修饰
    • 提供”set变量名(参数)“方法，用于设置成员变量的值，方法用public修饰
package MyPackage4;
/*学生类*/
public class Student {
    //成员变量
    String name;
//    int age;
    private int age;
    //提供get/set方法
    public void setAge(int a){
        if(a<0 || a>120){
            System.out.println("你给的年龄有误");
        } else{
            age=a;
        }
    }
    public int getAge(){
        return age;
    }
    //成员方法
    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage4;
/*学生测试类*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name="林青霞";
//        s.age=30;
//        s.setAge(-30);
        s.setAge(30);
        //调用show方法
        s.show();
    }
}

108private的使用

package MyPackage5;

public class Student {
    private String name;
    private int age;
    public void setName(String s){
        name = s;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage5;

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName()+"---"+s.getAge());
        System.out.println(s.getName()+","+s.getAge());
    }
}

109this

什么时候使用this呢？

  • 解决局部变量隐藏成员变量 （区分成员变量跟局部变量重名）

110this内存原理

 方法被哪个对象调用，this就代表哪个对象

111封装

  • 封装概述
    • 是面向对象的三大特征之一（封装，继承，多态）
    • 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  • 封装原则 
    • 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    • 成员变量private，提供对应的getXxx()/setXxx()方法
  • 封装好处
    • 通过方法来控制成员变量的操作，提高了代码的安全性
    • 把代码用方法进行封装，提高了代码的复用性 

112构造方法

构造方法：创建对象时，可以给成员变量赋值

  • 构造方法和它所在类的名字相同，但构造方法没有返回值 
  • 不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
package MyPackage6;
/*
*   学生类
*
*   构造方法：
*       作用：创建对象
*       功能：完成对象数据初始化
*   格式：
*       修饰符 类名(参数){
*
*       }
*       修饰符一般用：public
* */
public class Student {
    private String name;
    private int age;
    //构造方法
    public Student(){
        System.out.println("无参构造方法");
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage6;
/*测试类*/
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

113构造方法的注意事项

  • 构造方法的创建
    • 如果没有定义构造方法，系统将给出一个默认的无参构造方法
    • 如果定义了构造方法，系统将不再提供默认的构造方法
  • 构造方法的重载
    • 如果自定义了带参构造方法，还要使用无参构造方法，就必须再写一个无参构造方法 

    • 方法重载：就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

      • Java编译器根据方法签名判断哪个方法应该被调用。

      • 重载的方法必须拥有不同的参数列表。不能仅仅依据修饰符或者返回类型的不同来重载方法。

  • 推荐的使用方式
    • 无论是否使用，都手工书写无参构造方法 
package MyPackage7;

public class Student {
    private String name;
    private int age;
    public Student(){
        System.out.println("无参构造方法");
    }
    public Student(String name){
        this.name=name;
    }
    public Student(int age){
        this.age=age;
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage7;

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s =new Student();
        s.show();
        //public Student(String name)
        Student s1= new Student("林青霞");
        s1.show();
        //public Student(int age)
        Student s2= new Student(30);
        s2.show();
        //public Student(String name,int age)
        Student s3= new Student("林青霞",30);
        s3.show();
    }
}

运行结果： 

 "D:\Program Files\Java\jdk-11.0.15.1\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=60870:D:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\Mycode\JavaProject_Test\out\production\JavaProject_Test MyPackage7.StudentDemo
无参构造方法
null,0
林青霞,0
null,30
林青霞,30

Process finished with exit code 0

114标准类JavaBean

  • 成员变量
    • 使用private修饰
  • 构造方法
    • 提供一个无参构造方法
    • 提供一个带多个参数的构造方法 
  • 成员方法
    • 提供每一个成员变量对应的setXxx()/getXxx()
    • 提供一个显示对象信息的show() 
  • 创建对象并为其成员变量赋值的两种方式 
    • 无参构造方法创建对象后使用setXxx()赋值
    • 使用带参构造方法直接创建带有属性值的对象
package MyPackage8;
/*
    成员变量
        使用private修饰
    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法 
    成员方法
        提供每一个成员变量对应的setXxx()/getXxx()
        提供一个显示对象信息的show() 
* */
public class Student {
    //成员变量
    private String name;
    private int age;

//快捷键Alt+Insert或者Alt+Fn+insert
//插件PTG（联网——>File——>settings——>Plugins——>Marketplace搜索ptg——>install）1秒生成标准JavaBean类

    //构造方法
    //Alt+Insert--->Constructor--->2次tab键--->回车
    public Student(){}
    //Alt+Insert--->Constructor--->Ctrl+A全选--->回车
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    //成员方法
    //Alt+Insert--->Getter and Setter--->Ctrl+A全选--->回车
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

package MyPackage8;
/*
   创建对象并为其成员变量赋值的两种方式:
        1.无参构造方法创建对象后使用setXxx()赋值
        2.使用带参构造方法直接创建带有属性值的对象
* */
public class StudentDemo {
    public static void main(String[] args) {
        //1.无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
        //2.使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

安装标准的JavaBean类插件PTG——>1秒生成标准JavaBean类

 联网——>File——>settings——>Plugins——>Marketplace搜索ptg——>install

115API

116API的练习

package MyString;

import java.util.Scanner;

/*
*   Scanner:
*       用于获取键盘录入数据。（基本数据类型，字符串数据）
*   public String netLine():
*       获取键盘录入字符串数据
* */
public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("请输入一个字符串数据：");
//        String line = sc.nextLine()；通过对象调用方法，用line来接收
        //先写右边，然后Ctrl+Alt+V,然后选择变量名line来接收sc.nextLine()返回值
        String line = sc.nextLine();
        //输出结果
        System.out.println("你输入的数据是："+line);
    }
}

117String

118String构造方法 

package MyString;
/*
*   String构造方法：
*       1.public String():创建一个空白字符串对象，不含有任何内容
*       2.public String(char[] chs):根据字符数组的内容，来创建字符串对象
*       3.public String(byte[] chs):根据字节数组的内容，来创建字符串对象
*       4.String s = "abc";   直接赋值的方式创建字符串对象，内容就是abc
* 
*       推荐使用第4种————直接赋值的方式得到字符串对象
* */
public class StringDemo {
    public static void main(String[] args) {
        //public String():创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:"+s1);

        //public String(char[] chs):根据字符数组的内容，来创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println("s2:"+s2);

        //public String(byte[] chs):根据字节数组的内容，来创建字符串对象
        byte[] bys = {97,98,99};//对应a,b,c的ASCII码
        String s3 = new String(bys);
        System.out.println("s3:"+s3);

        //String s = "abc";   直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:"+s4);
    }
}

119String对象的特点

 

注意：

  • char[] chs = {'a','b','c'}; 是char[] chs = new char[]{'a','b','c'};的简化形式
  •  

120字符串的比较

package MyString;
/*
*   使用==做比较：
*       基本类型：比较的是数据值是否相同
*       引用类型：比较的是地址值是否相同
*
*   public boolean equals(Object anObject):
*       将此字符串与指定对象进行比较。由于我们比较的是字符串对象，使用参数直接传递一个字符串
* */
public class StringCompare {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a','b','c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1 == s2);//false
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//true
        System.out.println("--------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));//true
        System.out.println(s1.equals(s3));//true
        System.out.println(s3.equals(s4));//true
    }
}

121用户登录

package BasicPractice;

import java.util.Scanner;

/*
*   需求：
*       已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登陆之后，给出相应的提示
*   思路：
*       1.已知用户名和密码，定义两个字符串表示即可
*       2.键盘录入要登录的用户名和密码，用Scanner实现
*       3.拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals()方法实现
*       4.用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
* */
public class UserSignIn {
    public static void main(String[] args) {
        //1.已知用户名和密码，定义两个字符串表示即可
        String username = "joy";
        String password = "123456";

        //4.用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for(int i=0;i<3;i++){
            //2.键盘录入要登录的用户名和密码，用Scanner实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();
            //3.拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals()方法实现
            if(name.equals(username) && pwd.equals(password)){
                System.out.println("登录成功");
            }else{
                //2,1,0
                //i,0,1,2
                System.out.println("登录失败，你还有"+(2-i)+"次机会");
            }

        }
    }

}

122遍历字符串

package BasicPractice;

import java.util.Scanner;

public class String_traverse {
    public static void main(String[] args) {
        //键盘输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        //遍历字符串，首先要能够获取到字符串中的每一个字符串,其次要能够得到字符串的长度
//        System.out.println(line.charAt(0));
//        System.out.println(line.charAt(1));
//        System.out.println(line.charAt(2));
        for(int i=0;i<line.length();i++){
            System.out.println(line.charAt(i));
        }
    }
}

123统计字符次数

package BasicPractice;

import java.util.Scanner;

public class Count_Characters {
    public static void main(String[] args) {
        //键盘输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //遍历字符串，得到每一个字符
        for(int i=0;i<line.length();i++){
            char ch = line.charAt(i);
            //判断该字符属于哪种类型，对应统计变量+1
            if(ch>='A' && ch<='Z'){
                bigCount++;
            }else if(ch>='a' && ch<='z'){
                smallCount++;
            }else if(ch<='0' && ch>='9'){
                numberCount++;
            }
        }

        //输出三种类型的字符个数
        System.out.println("大写字母："+bigCount+"个");
        System.out.println("小写字母："+smallCount+"个");
        System.out.println("数字："+numberCount+"个");
    }
}

124字符串拼接

package BasicPractice;

public class String_splicing {
    public static void main(String[] args) {
        //定义一个int类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:"+s);
    }
    //定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回
    /*
    *   两个明确：
    *       返回值类型：String
    *       参数：int[] arr
    * */
    public static String arrayToString(int[] arr){
        //在方法中遍历数组，按照要求进行拼接
        String s = "";
        s += "[";
        for (int i=0;i<arr.length;i++){
            if(i==arr.length-1){
                s += arr[i];
            }else{
                s += arr[i];
                s += ",";
            }
        }
        s += "]";
        return s;
    }
}

125字符串反转

package BasicPractice;

import java.util.Scanner;

public class String_Reverse {
    public static void main(String[] args) {
        //键盘录入一个字符串，用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //调用方法，用一个变量接收结果
        String s = reverse(line);

        //输出结果
        System.out.println("S:"+s);
    }
    //定义一个方法，实现字符串反转
    /*
    *   两个明确：
    *       返回值类型：String
    *       参数：String s
    * */
    public static String reverse(String s){
        //在方法中把字符串倒着遍历，然后把得到的每一个字符拼接成一个字符串返回
        String ss = "";

        for(int i=s.length()-1;i>=0;i--){
            ss += s.charAt(i);
        }

        return ss;
    }

}

126帮助文档查看String方法

补充：Object类 

  

127StringBuilder

  •  StringBuilder是一个可变（StringBuilder对象中的内容是可变的）的字符串类，我们可以把它看成是一个容器
  • String和StringBuilder的区别：
    • String：内容是不可变的
    • StringBuilder：内容是可变的

128StringBuilder构造方法

  • public StringBuilder()        创建空白可变字符串对象，不含有任何内容
  • public StringBuilder(String str)        根据字符串的内容，来创建可变字符串对象
package BasicPractice;

public class StringBuilderDemo1 {
    public static void main(String[] args) {
        //public StringBuilder():创建空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:"+sb);
        System.out.println("sb.length():"+sb.length());
        //public StringBuilder(String str):根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:"+sb2);
        System.out.println("sb2.length():"+sb2.length());

    }
}

129StringBuilder添加和反转

  • public StringBuilder append(任意类型)        添加数据，并返回对象本身
  • public StringBuilder reverse()        返回相反的字符串序列
package BasicPractice;

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

        //public StringBuilder append(任意类型):添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//        System.out.println("sb:"+sb);
//        System.out.println("sb2:"+sb2);
//        System.out.println(sb == sb2);//结果为true，说明sb和sb2是同一个对象

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append("100");
//        System.out.println("sb:"+sb);

        //链式编程
        sb.append("hello").append("world").append("java").append("100");
        System.out.println("sb:"+sb);

        //public StringBuilder reverse():返回相反的字符串序列
        sb.reverse();
        System.out.println("sb:"+sb);
    }
}

130StringBuilder和String相互转换

  • StringBuilder转换为String
    • public String toString():通过toString()就可以实现把StringBuilder转换为String
  • String转换为StringBuilder
    • public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
package BasicPractice;

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        
        /*
        //StringBuilder转换为String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
//        String s = sb;//错误
        //public String toString():通过toString()就可以实现把StringBuilder转换为String
        String s = sb.toString();
        System.out.println(s);
        */
        
        //String转换为StringBuilder
        String s = "hello";
//        StringBuilder sb = s;//错误
        //public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
        StringBuilder sb = new StringBuilder(s);
        System.out.println(sb);

    }
}

131字符串拼接升级版

package BasicPractice;

public class String_splicing_v2 {
    public static void main(String[] args) {
        //定义一个int类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1,2,3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:"+s);
    }
    //定义一个方法，用StringBuilder按照要求进行拼接，并把结果转成String返回
    /*
     *   两个明确：
     *       返回值类型：String
     *       参数：int[] arr
     * */
    public static String arrayToString(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i=0;i<arr.length;i++){
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");

        String s = sb.toString();
        return s;
    }
}

升级版：使用了StringBuilder，既节省空间，又提高了效率 

132字符串反转升级版

package BasicPractice;

import java.util.Scanner;

public class String_Reverse_v2 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用Scanner实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        //调用方法，用一个变量接收结果
        String s = reverse(line);

        //输出结果
        System.out.println("S:"+s);
    }
    //定义一个方法，使用StringBuilder实现字符串反转,并把结果转成String返回
    /*
     *   两个明确：
     *       返回值类型：String
     *       参数：String s
     * */
    public static String reverse(String s){
        //String---StringBuilder---reverse()---String
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;
        return new StringBuilder(s).reverse().toString();
    }
}

133帮助文档查看StringBuilder方法

134ArrayList

  • 集合概述
    • 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
    • 集合类有很多，比如ArrayList
  •  ArrayList<E>:
    • 可调整大小的数组实现
    • <E>:是一种特殊的数据类型，泛型。
  • 如何使用？
    •  在出现E的地方我们使用引用数据类型替换即可
    • 举例：ArrayList<String>,ArrayList<Student> 

135ArrayList构造和添加

package BasicPractice;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //public ArrayList():创建一个空的集合对象
//        ArrayList<String> array = new ArrayList<>();
        ArrayList<String> array = new ArrayList<String>();

        //public boolean add(E,e):将指定元素追加到此集合的末尾
//        System.out.println(array.add("hello"));
        array.add("hello");
        array.add("world");
        array.add("java");

        //public void add(int index,E element):此集合中指定位置插入指定的元素
        array.add(1,"javase");
//        array.add(3,"javase");
//        array.add(4,"javase");//index out of bounds exception
        
        //输出集合
        System.out.println("array:"+array);
    }
}

136ArrayList常用方法

package BasicPractice;

import java.util.ArrayList;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> array = new ArrayList<String>();

        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

//        //public boolean remove(Object o):删除指定元素，返回删除是否成功
//        System.out.println(array.remove("world"));//true
//        System.out.println(array.remove("javase"));//false

//        //public E remove(int index):删除指定索引处的元素，返回被删除的元素
//        System.out.println(array.remove(1));
        System.out.println(array.remove(3));//index out of bounds exception

//        //public E set(int index，E element):修改指定索引处的元素，返回被修改的元素
//        System.out.println(array.set(1,"javase"));
        System.out.println(array.set(3,"javase"));//index out of bounds exception

//        //public E get(int index):返回指定索引处的元素
//        System.out.println(array.get(0));
//        System.out.println(array.get(1));
//        System.out.println(array.get(2));
//        System.out.println(array.get(3));//index out of bounds exception

        //public int size():返回集合中元素的个数
        System.out.println(array.size());

        //输出集合
        System.out.println("array:"+array);
    }
}

137ArrayList存储字符串并遍历

package BasicPractice;

import java.util.ArrayList;

public class ArrayListTest1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        //往集合中添加字符串对象
        array.add("张三");
        array.add("李四");
        array.add("王五");

        //遍历集合，首先要能够获取到集合中每一个元素，这个通过get(int index)方法实现
//        System.out.println(array.get(0));
//        System.out.println(array.get(1));
//        System.out.println(array.get(2));
        //遍历集合通用格式
        for(int i=0;i<array.size();i++){
            String s = array.get(i);
            System.out.println(s);
        }
    }
}

138ArrayList存储学生对象并遍历

package ArrayList_Package;
/*学生类*/
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student(){}

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    //setXxx()/getXxx()方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age=age;
    }

    public int getAge(){
        return age;
    }
}

package ArrayList_Package;

import java.util.ArrayList;

/*
*   需求：
*       创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合
*   思路：
*       1.定义学生类
*       2.创建集合对象
*       3.创建学生对象
*       4.添加学生对象到集合中
*       5.遍历集合，采用通用遍历格式实现
* */
public class ArrayListTest2 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array =new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("林青霞",30);
        Student s2 = new Student("风清扬",33);
        Student s3 = new Student("张曼玉",18);

        //添加学生对象到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //遍历集合，采用通用遍历格式实现
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

139ArrayList存储学生对象并遍历升级版

package ArrayList_Test2;
/*
*   学生类
*       为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
* */
public class Student {
    //成员变量
    private String name;
    private String age;

    //构造方法
    public Student(){}

    public Student(String name,String age){
        this.name=name;
        this.age=age;
    }

    //setXxx()/getXxx()方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

    public void setAge(String age){
        this.age=age;
    }

    public String getAge(){
        return age;
    }
}

package ArrayList_Test2;

import java.util.ArrayList;
import java.util.Scanner;

/*
 *   需求：
 *       创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合
 *       学生的姓名和年龄来自于键盘输入
 *   思路：
 *       1.定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
 *       2.创建集合对象
 *       3.键盘录入学生对象所需要的数据
 *       4.创建学生对象，把键盘录入的数据赋值给学生变量
 *       5.在集合中添加学生对象
 *       6.遍历集合，采用通用遍历格式实现
 * */
public class ArrayListTest2 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();
        /*
        //键盘录入学生对象所需要的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();

        //创建学生对象，把键盘录入的数据赋值给学生变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age);

        //在集合中添加学生对象
        array.add(s);
         */

        //为了提高代码复用性，用方法来改进程序
        addStudent(array);
        addStudent(array);
        addStudent(array);

        //遍历集合，采用通用遍历格式实现
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
    /*
    *   两个明确：
    *       返回值类型：void
    *       参数：ArrayList<Student> array
    * */
    public static void addStudent(ArrayList<Student> array){
        //键盘录入学生对象所需要的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();

        //创建学生对象，把键盘录入的数据赋值给学生变量
        Student s = new Student();
        s.setName(name);
        s.setAge(age);

        //在集合中添加学生对象
        array.add(s);
    }
}

140——149学生管理系统

 

 

 

package myPackage;
/*
*   学生类
*   Alt+Insert:根据自己的需要，自行选择
* */
public class Student {
    private String sid;
    private String name;
    private String age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, String age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

package myPackage;

import java.util.ArrayList;
import java.util.Scanner;

/*学生管理系统*/
public class StudentManager {
    /*
    *   1.用输出语句完成主界面的编写
    *   2.用Scanner实现键盘录入数据
    *   3.用switch语句完成操作的选择
    *   4.用循环完成再次回到主界面
    * */
    public static void main(String[] args) {
        //创建集合对象，用于存储学生数据
        ArrayList<Student> array = new ArrayList<Student>();

        //用循环完成再次回到主界面
        while(true) {
            //用输出语句完成主界面的编写
            System.out.println("----------欢迎来到学生管理系统----------");
            System.out.println("1 添加学生");
            System.out.println("2 删除学生");
            System.out.println("3 修改学生");
            System.out.println("4 查看所有学生");
            System.out.println("5 退出");
            System.out.println("请输入你的选择：");

            //用Scanner实现键盘录入数据
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();

            //用switch语句完成操作的选择
            switch (line) {
                case "1":
//                    System.out.println("添加学生");
                    addStudent(array);
                    break;
                case "2":
//                    System.out.println("删除学生");
                    deleteStudent(array);
                    break;
                case "3":
//                    System.out.println("修改学生");
                    updateStudent(array);
                    break;
                case "4":
//                    System.out.println("查看所有学生");
                    findStudent(array);
                    break;
                case "5":
                    System.out.println("谢谢使用");
//                    break;
                    System.exit(0);//JVM退出
            }
        }
    }

    //定义一个方法，用于添加学生信息
    /*
    public static void addStudent(ArrayList<Student> array){
        //键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入学生学号：");
        String sid = sc.nextLine();
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生居住地：");
        String address = sc.nextLine();

        //创建学生对象，用键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);

        //将学生对象添加到集合中
        array.add(s);
    }
    */
    public static void addStudent(ArrayList<Student> array){
        //键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
        Scanner sc = new Scanner(System.in);

        //为了让sid在while循环外面也能被访问到，我们把它定义在循环外
        String sid;

        //为了让程序能够回到这里，用循环实现
        while (true){
            System.out.println("请输入学生学号：");
            sid = sc.nextLine();

            boolean flag = isUsed(array,sid);
            if(flag){
                System.out.println("你输入的学号已经被使用，请重新输入");
            }else {
                break;
            }
        }

        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生居住地：");
        String address = sc.nextLine();

        //创建学生对象，用键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);

        //将学生对象添加到集合中
        array.add(s);
    }

    //定义一个方法，判断学号是否被使用
    public static boolean isUsed(ArrayList<Student> array,String sid){
        //如果与集合中的某一个学生学号相同，返回true；如果都不相同，返回false
        boolean flag = false;

        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            if(s.getSid().equals(sid)){
                flag=true;
                break;
            }
        }

        return flag;
    }

    //定义一个方法，用于查看学生信息
    public static void findStudent(ArrayList<Student> array){
        //判断集合中是否有数据，如果没有显示提示信息
        if(array.size()==0){
            System.out.println("无信息，请先添加信息再查询");
            //为了让程序不再往下执行，给出return;
            return;
        }

        //显示表头信息
        System.out.println("学号\t\t姓名\t\t年龄\t\t居住地");//\t:其实就是tab键的位置

        //将集合中数据提取出按照对应格式显示学生信息，年龄显示补充“岁”
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s.getSid()+"\t"+s.getName()+"\t\t"+s.getAge()+"岁\t"+s.getAddress());
        }
    }

    //定义一个方法，用于删除学生信息
    /*
    public static void deleteStudent(ArrayList<Student> array){
        //键盘录入要删除的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要删除的学生的学号：");
        String sid = sc.nextLine();

        //遍历集合将对应学生对象从集合中删除
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            if(s.getSid().equals(sid)){
                array.remove(i);
                break;
            }
        }
        //给出删除成功提示
        System.out.println("删除学生成功");
    }
    */
    public static void deleteStudent(ArrayList<Student> array){
        //键盘录入要删除的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要删除的学生的学号：");
        String sid = sc.nextLine();

        //在删除/修改学生操作前，对学号是否操作进行判断
        //如果不存在，显示提示信息
        //如果存在，执行删除/修改操作
        int index = -1;
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            if(s.getSid().equals(sid)){
                index = i;
                break;
            }
        }
        if(index==-1){
            System.out.println("该信息不存在，请重新输入");
        }else{
            array.remove(index);
            //给出删除成功提示
            System.out.println("删除学生成功");
        }
    }

    //定义一个方法，用于修改学生信息
    public static void updateStudent(ArrayList<Student> array){
        //键盘录入要修改的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要修改的学生的学号：");
        String sid = sc.nextLine();

        //键盘录入要修改的学生信息
        System.out.println("请输入学生新姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生新年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生新居住地：");
        String address = sc.nextLine();
        System.out.println("请输入学生新姓名：");

        //创建学生对象
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);

        //遍历集合修改对应的学生信息
        for(int i=0;i<array.size();i++){
            Student student = array.get(i);
            if(student.getSid().equals(sid)){
                array.set(i,s);
                break;
            }
        }

        //给出修改成功提示
        System.out.println("修改学生成功");
    }

}
西欢乐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA学习笔记（二）
qq_45982367的博客
03-24 537
JAVA学习笔记（二）一、程序二、进程，线程三、并发，并行 一、程序 我们常说的程序本质上就是一系列指令的集合，程序这个概念相对静态，对应于操作系统中的一个可执行文件，就比如当我们要玩LOL时，这个时候LOL就是一个可执行程序。 二、进程，线程 当我们双击点开LOL，这个时候整个LOL程序就被加载到内存中，程序开始执行，这个时候就产生了进程，所以我们将执行中的程序称之为进程，进程就是程序的动态执行的过程，每个进程都会占用一定的cpu，并且有着自己的数据和代码，并且进程之间相互独立。 在进程中，可以产生多个线
JAVA学习笔记（类的学习）
qq_50834939的博客
11-11 621
JAVA学习笔记（类的学习）类声明和类体构造方法和对象创建 类声明和类体 类是组成Java程序的主要元素，封装了类对象的状态和方法。类是用来定义对象的模板。类由两部分组成：类声明和类体。基本格式如下： class 类名{ 类体 } 类体的构成 类体内容有两个成员：成员变量和方法。 通过变量声明定义的变量，称为成员变量或域，用来刻画累的创建对象的属性。 例如 构造方法和对象创建 类中有一部分方法成为构造方法，构造方法攻擂创建对象，用来给出类的对象的初始状态。构造方法是一种特殊的方法，构造方法的方法名必须与
java大数据开发第六天（javaSE基础）------Random
eigtheen的博客
02-09 245
一、Random 作用：产生一个随机数 使用步骤： 1.导包： import java.util.Random; 2.创建对象： Random r = new Random(); 3.获取随机数： int number = r.nextInt(10); 获取数据的范围：[0,10)包括0，不包括10 import java.util.Random; public cla...
Java中的随机数
qq_53551331的博客
09-05 1749
Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能生成指定范围的随机数；n~m之间的数字（包括n，不包括m）， nextInt(m-n)+n。包含数的时候还要加1
c语言生成随机数猜数字大小,产生一个随机数，进行猜数字小游戏
weixin_36226933的博客
05-18 2176
产生随机数Random:用于产生随机数使用步骤：1.导包import java.util.Random;2.创建对象Random r = new Random();3.获取随机数int number = r.nextInt(100);获取数据的范围：[0,100) 包括0,不包括100猜数字小游戏案例1.系统产生一个1-100之间的随机数Random r = new Random();int nu...
Java基础语法
热门推荐
terence的博客
03-27 9万+
1. Java概述 1.1 Java语言发展史 语言:人与人交流沟通的表达方式 计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言 Java之父:詹姆斯·高斯林(James Gosling) 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com 当前，我们课程使用的JDK版本:11.0 1.2 Java语言跨平台原理
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
爬虫学习日记
最新发布
wuhu_czy的博客
07-12 342
爬虫python code
“Numpy数据分析与挖掘：高效学习重点技能“
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
07-10 948
在计算统计中，如果把nan的值替换为0进行统计，这样并不合适，替换之前的平均值如果大于0，替换之后均值肯定会变小；统计存在有nan的列，将nan的列中其它不等于nan的值进行mean求出均值，：小于15000的赋值为15000，大于等于50000的赋值为50000。：小于15000的赋值为0，大于等于15000的赋值为10。将统计除nan列的均值，再将均值赋值给当前列的nan值上；在数组运算中，不同的列，但是相同的行，是可以进行运算的；1.均匀分布：在相同的大小范围内的出现概率是等可能的；
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 663
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 545
ROS运行管理。
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 298
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
【安卓学习】文本切换器
m0_73241073的博客
07-08 648
文本切换器的使用
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 572
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 440
Qt/QML学习-动画元素
JAVA学习笔记整理(全)
06-03
目录 JAVA 1 一、 基础语法 1 二、 MYSQL 33 三、 Nginx 60 四、 Redis 67 五、 Mybatis 75 六、 Spring 77 七、 Docker 84 八、 计算机网络 86 九、 JVM 96 十、 Springboot 111 十一、 RabbitMQ 112 十二、 其它 115 十三、 操作系统 126 十四、 数据结构 133 十五、Linux 133

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值