记录我的java学习笔记和作业，学习资料来源于黑马程序员。
1、 入门
1.1 day01作业
1、多选题：任何计算机能执行的东西都是程序，下面的内容哪些是程序？
A。操作系统
B。360浏览器
C。安卓app
D。电脑病毒
答案：ABCD
讲解：
只要是我们人为编写的，都是程序。
计算机中的程序有系统软件还有应用软件。
2、基础概念
2.1 字面量
2.2 不同进制
2.3 数据类型
byte的范围需要记住；
2^31 = 2,147,483,648; 2^63 = 9,223,372,036,854,775,808；
boolean为布尔型；
2.4 命名规则
2.5 录入Scanner
两套体系不能混用！
2.6 IDEA项目结构
项目-微信；
模块-通讯录、发现、我等下方内容；
包（像文件夹）-文字、图片、动画等；
类-实现的代码。
项目：basic-code；
模块（module）：day02-code；
包（package）：demo1；
类（class）：Helloworld。
2.7 day02作业
1：（选择）下列关于java变量声明那个是错误的：
A . int x = 5;
B. double d = 3.14;
C. char grade = ‘C’;
D. String name = ‘黑马程序员’;
**讲解：D**
**字符串需要用双引号引起来**
2：（选择题）变量名是一个单词或者是一组单词，用来描述一个数据的含义，方便人理解，变量名不能有空格。下面的名字哪些可以是变量名?
A. mybirthday
B. myname
C. my name
D. my birthday
E. 1987.
F. ”传智播客”
**讲解：**
**AB正确，其他错误**
**C：不能有空格**
**D：不能有空格**
**E：不能以数字开头**
**F：变量名不能有双引号**
3：（选择题）下面代码哪些是创建一个变量?
A. int myAge = 18;
B. myName='传智播客”;
C. myAge = 16;
D. String myName ;
**讲解：**
A：正确
B：错误，缺少数据类型，而且数据值也错误
C：错误，缺少数据类型
D：错误，没有赋值
4：（代码题）变量应该是先声哪后使用,请完成下面代码
A.声明字符串型变量name
B.声明字符串型变量birthday
C.声明整数类型变量age
D.声明float类型变量money
**讲解：**
A:String name = "尼古拉斯阿玮";
B:String birthday = "9月10日";
C:int age = 18;
D:float money = 999999999.99F;
5：请编写程序，分别定义8种基本数据类型的变量，并打印变量的值。
public class Test01 {
public static void main(String[] args) {
// 定义byte类型变量，值为整数，只要在byte范围即可，byte范围：-128 ~ 127
byte b = 100;
System.out.println(b);
// 定义short类型变量，值为整数，只要在short范围即可
short s = 12345;
System.out.println(s);
// 整数的默认类型就是int类型
int num = 654321;
System.out.println(num);
// 定义long类型的整数，需要在数据的后面加字母（L），大小写不限，建议大写。
long lo = 123456789L;
System.out.println(lo);
// 定义float类型的浮点数，需要在数据的后面加字母（F），大小写不限，建议大写。
float f = 1.5F;
System.out.println(f);
// 浮点型默认类型double
double d = 123.456;
System.out.println(d);
// 布尔型只有两个取值：true和false
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);
System.out.println(b2);
// 定义字符型需要一对英文的单引号包裹，并且只能包含一个字符
char c = 'a';
System.out.println(c);
// 定义字符串型需要一对英文的双引号包裹
String str = "中国";
System.out.println(str);
}
}
6.将以下内容输出到屏幕上
************************
我的姓名是：张三
我的性别是：男
我的年龄是：18
我的地址是：xx省xx市
我的饭卡余额是：55.55元
************************
public class Test03 {
public static void main(String[] args) {
// 姓名
String name = "张三";
// 性别
String gender = "男";
// 年龄
int age = 20;
// 地址
String address = "美国芝加哥";
// 余额
double money = 88.88;
System.out.println("************************");
System.out.println("我的姓名是：" + name); // 在输出语句中将变量与字符串拼接
System.out.println("我的性别是：" + gender);
System.out.println("我的年龄是：" + age);
System.out.println("我的地址是：" + address);
System.out.println("我的饭卡余额是：" + money + "元");
System.out.println("************************");
}
}
3、运算符
3.1 算术运算符
3.1.1 数值拆分练习
总结的规律：数值 / (想要得到的位数）%10
import java.util.Scanner;
public class sanweishu {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个三位数");
int number=sc.nextInt();
int bai=number/100;
int shi=number/10%10;
int ge=number%10;
System.out.println("百位："+bai);
System.out.println("十位："+shi);
System.out.println("个位："+ge);
}
}
3.2 隐式转换与强制转换
3.2.1 隐式转换
自动小转大
3.2.2 强制转换
强制转换超过范围就会出错！
3.3 字符串和字符串的加操作
* ASCII码表
需要记住：A——65；a——97；
当 数字与字符相加时，字符对应的ASCII数值参与计算；
当有字符串参与计算时，+号起拼接作用。（字符串不能进行 “ - ”，“ * ”，“ / ” 操作）
3.4 自增（++）自减（--）运算符
3.5 赋值运算符与关系运算符
3.5.1 赋值运算符
注意！存在强制转换！
3.5.2 关系运算符
3.5.3 逻辑运算符
异或的有趣记忆法：民政局登记结婚，性别相同不行，不同可以。
3.5.4 短路逻辑运算符
结果与普通的单个逻辑运算符一致，区别在于当左边的表达式能够判断最终结果时，右边就不再参与计算了。
* 练习题 数字6
import java.util.Scanner;
public class number6 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个整数：");
int number1= sc.nextInt();
System.out.println("请输入第二个整数：");
int number2= sc.nextInt();
//用短路逻辑运算符更有效率
boolean result=(number1==6)||(number2==6)||((number1+number2)%6==0);
System.out.println(result);
}
}
3.5.5 三元运算符
关系表达式为真则返回表达式1，假返回表达式2
小tips：ctrl+alt+L自动对齐代码
3.5.6 原码反码补码
原码：最左边为符号位，0正1负
反码：正数的反码不变；负数在原码的基础上，符号位不变，数值全部取反
补码：正数的补码不变；负数在反码的基础上，加1
在计算机中，数字的存储和运算都以补码形式进行
1个字节8个比特位
简便计算方法：左移一次就是结果×2，右移就是÷2
右移补0和1要与该数的符号位相同，正数补0，负数补1
4、判断与循环
4.1 if
4.2 switch
JDK12以后的新版本可以简化成以下形式：
不需要写break，但仍和传统形示有break的功能相同。这里由于每个case里语句只有一行，所以没有写{ }
合理运用case穿透：
也可以这样改写：
再次简化：
4.3 for
要注意变量定义的位置！：
写循环时的快捷方式！
输入回车就得到下面
4.4 while
4.5 练习题：回文数
package test1;
import java.util.Scanner;
public class huiwenshu {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数");
int number= sc.nextInt();
int temp=number;
int num=0;
while (temp!=0){
int ge=temp%10;//个位数
temp=temp/10;//去掉个位数
num=num*10+ge;//倒着拼接数字
}
System.out.println(num==number);
}
}
4.6 练习题：求商和余数
package test1;
import java.util.Scanner;
public class shangheyushu {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入被除数");
int beichu=sc.nextInt();
System.out.println("请输入除数");
int chu=sc.nextInt();
int num=beichu;
int shang=0;
while (num>=chu){
num=num-chu;
shang++;
}
System.out.println("商为"+shang+",余数为"+num);
}
}
4.7 do……while
5、循环高级综合练习
5.1 跳转
break——结束循环；continue——跳出本次循环，继续下次循环。
5.2 练习：逢7过
public class feng7guo {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if(i%7==0||i%10==7||i/10==7){
System.out.println("过");
}else{
System.out.println(i);
}
}
}
}
5.3 练习：判断是否为质数
5.4 random
6、数组
6.1 静态初始化
数组的长度：
快速生成循环：arr.fori
6.2 动态初始化
数组常见问题：访问了不存在的索引，出现索引越界异常
打印时不换行小技巧：去掉println中的ln，后面可以加一个空格作为间隔
6.3 数组的内存图
区别在于一个存储的是真实的数据，一个存储的是地址。
6.4 练习题：把数字按大小顺序放入数组序列中
有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下：
请输入一个整数数字：
50
生成的新数组是：12 14 23 45 50 66 68 70 77 90 91
package test1;
import java.util.Scanner;
public class insertarr {
public static void main(String[] args) {
int[] arr={12,14,23,45,66,68,70,77,90,91};
Scanner sc=new Scanner(System.in);
System.out.println("请输入要插入的整数");
int num=sc.nextInt();
int[] arr1=new int[arr.length+1];
int i;
for (i = 0; i < arr1.length; i++) {
if(arr[i]<num){
arr1[i]=arr[i];
}else{
arr1[i]=num;
arr1[i+1]=arr[i];
break;
}
}
// System.out.println(i);
int j;
for (j=i+2; j < arr1.length; j++) {
arr1[j]=arr[j-1];
}
for (int i1 = 0; i1 < arr1.length; i1++) {
System.out.print(arr1[i1]+" ");
}
}
}
6.5 二维数组
分行写可读性高
7、方法
7.1 最简单的方法定义与调用
7.2 带参数的方法定义与调用
7.3 带返回值的方法定义与调用
7.4 方法的重载
这里方法名相同，参数也相同，所以不构成重载，重载与否与返回值无关：
方法名相同，参数不同（个数不同），因而构成重载：
虽然满足了方法名相同，参数不同（类型不同）这两个条件，但不在同一个类里，因而不构成重载：
方法名相同，参数不同（顺序不同），因而构成重载。不建议是因为没必要，使用方法时将实参换个顺序即可实现：
比较两整数是否相同：
换行小技巧：System.out.println(); //不打印数据，只换行
7.5 方法的内存
方法被调用以后就会进栈执行，结束后出栈，方法中定义过的变量也随之消失。
7.6 作业练习题：抽奖不重复
一个大V直播抽奖，奖品是现金红包，分别有{2,588,888,1000,10000}五个奖金。请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：（随机顺序，不一定是下面的顺序）
888元的奖金被抽出
588元的奖金被抽出
10000元的奖金被抽出
1000元的奖金被抽出
2元的奖金被抽出
package test1;
import java.util.Random;
public class choujiang {
public static void main(String[] args) {
int[] arr={2,588,888,1000,10000};
int count=0;
while (count<5){
Random r=new Random();
int index=r.nextInt(5);//0~4
if(arr[index]!=0){
System.out.println(arr[index]+"元的奖金被抽出");
arr[index]=0;
count++;
}
}
}
}
更简便的方法：
7.7 从代码中抽取方法的快捷键：ctrl+alt+M
①选中需要抽取方法的代码，按上述快捷键
②选择接受相同的代码抽取成方法
③是否需要用方法替代在代码中，选择替代
7.8 把大写和小写字母放到数组中的代码
7.9 循环拼接字符串的代码
8、综合练习
8.1 数字加密
package test1;
import java.util.Scanner;
public class encode {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int[] arr=new int[4];
System.out.println("请输入四位密码");
//输入密码
for (int i = 0; i < arr.length; i++) {
arr[i]=sc.nextInt();
}
//加密
int[] arr1=new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i]=(arr[i]+5)%10;//加5然后模10
// System.out.println(arr1[i]);
}
//翻转
int[] arr2=new int[arr.length];
for (int i = 0; i < arr2.length; i++) {
arr2[i]=arr1[arr1.length-i-1];
System.out.print(arr2[i]);
}
}
}
9、面向对象
9.1 类和对象
举例：
9.2 封装
为了保证数据的安全性，定义变量时用private可以禁止类外访问；用set和get变量方法给变量赋值和提供参数，这里用public
9.3 就近原则和this
上面age是成员变量，下面是局部变量。没有this时就近原则。
为了见名知意
9.4 构造方法
创建对象是new做的
9.5 标准的javabean类
固定格式（套路）：
* 快捷键：
无参构造：
有参构造：
set和get方法：
更快的方法：插件
file-settings:
全部自动生成
9.6 对象内存图
9.7 基本数据类型和引用数据类型
引用可以理解为拿别人的空间过来用
9.8 this的内存原理
9.9 成员和局部
9.10 作业题
定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。
请定义出手机类，类中要有空参、有参构造方法，set/get方法。
定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。
调用对象的两个功能，打印效果如下：
正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....
package homework;
public class Phonetest {
public static void main(String[] args) {
Phone p=new Phone();
p.setPrice(3998);
p.setColor("黑色");
p.setBrand("小米手机");
p.call();
p.message();
}
}
package homework;
public class Phone {
private String brand;
private int price;
private String color;
public Phone() {
}
public Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
/**
* 获取
* @return brand
*/
public String getBrand() {
return brand;
}
/**
* 设置
* @param brand
*/
public void setBrand(String brand) {
this.brand = brand;
}
/**
* 获取
* @return price
*/
public int getPrice() {
return price;
}
/**
* 设置
* @param price
*/
public void setPrice(int price) {
this.price = price;
}
/**
* 获取
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
* @param color
*/
public void setColor(String color) {
this.color = color;
}
public void call(){
System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"打电话");
}
public void message(){
System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"发短信");
}
}
也可以这样赋值：
public class Phonetest {
public static void main(String[] args) {
Phone p=new Phone("小米手机",3998,"黑色");
// p.setPrice(3998);
// p.setColor("黑色");
// p.setBrand("小米手机");
p.call();
p.message();
}
}
10、面向对象综合练习
10.1 文字版格斗游戏
package homework;
import java.util.Random;
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return blood
*/
public int getBlood() {
return blood;
}
/**
* 设置
* @param blood
*/
public void setBlood(int blood) {
this.blood = blood;
}
public void attack(Role role){
//随机1-20的伤害
Random r=new Random();
int hurt=r.nextInt(20)+1;
//计算剩余血量
int remainBlood=role.getBlood()-hurt;
//血量不能为负数
remainBlood = (remainBlood < 0) ? 0 : remainBlood;
//修改挨揍的人的血量
role.setBlood(remainBlood);
//this表示方法的调用者，也就是发起攻击的人，传递进来的参数role是挨揍的人
System.out.println(this.getName()+"打了"+role.getName()+"一拳，造成了"+hurt+"点的伤害，"+role.getName()+"还剩"+remainBlood+"点血");
}
}
package homework;
public class GameTest {
public static void main(String[] args) {
//创建角色
Role r1=new Role("乔峰",100);
Role r2=new Role("鸠摩智",100);
//开始攻击
while(true){
//乔峰攻击
r1.attack(r2);
if(r2.getBlood()==0){
System.out.println("乔峰KO了鸠摩智");
break;
}
//鸠摩智攻击
r2.attack(r1);
if(r1.getBlood()==0){
System.out.println("鸠摩智KO了乔峰");
break;
}
}
}
}
* printf（快捷键souf）
* 游戏升级版
package game;
public class GameTest {
public static void main(String[] args) {
//创建角色
Role r1=new Role("乔峰",100,'男');
Role r2=new Role("鸠摩智",100,'女');
//查看容貌
r1.showinfo();
r2.showinfo();
//开始攻击
while(true){
//乔峰攻击
r1.attack(r2);
if(r2.getBlood()==0){
System.out.println("乔峰KO了鸠摩智");
break;
}
//鸠摩智攻击
r2.attack(r1);
if(r1.getBlood()==0){
System.out.println("鸠摩智KO了乔峰");
break;
}
}
}
}
package game;
import java.util.Random;
public class Role {
private String name;
private int blood;
private char gender;
private String face;
//容貌描述
String[] boyfaces= {"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
String[] girlfaces ={"美奂绝伦","沉鱼落雁","婷婷玉立","身材娇好","相貌平平","相貌简陋","惨不忍睹"};
//attack 攻击描述：
String[] attacks_desc={
"%s使出了一招【背心钉】，转到对方的身后，一掌向%s背心的灵台穴拍去。",
"%s使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向%s。",
"%s大喝一声，身形下伏，一招【劈雷坠地】，捶向%s双腿。",
"%s运气于掌，一瞬间掌心变得血红，一式【掌心雷】，推向%s。",
"%s阴手翻起阳手跟进，一招【没遮拦】，结结实实的捶向%s。",
"%s上步抢身，招中套招，一招【劈挂连环】，连环攻向%s。"
};
//injured 受伤描述：
String[] injureds_desc={
"结果%s退了半步，毫发无损",
"结果给%s造成一处瘀伤",
"结果一击命中，%s痛得弯下腰",
"结果%s痛苦地闷哼了一声，显然受了点内伤",
"结果%s摇摇晃晃，一跤摔倒在地",
"结果%s脸色一下变得惨白，连退了好几步",
"结果『轰』的一声，%s口中鲜血狂喷而出",
"结果%s一声惨叫，像滩软泥般塌了下去"
};
public Role() {
}
public Role(String name, int blood, char gender) {
this.name = name;
this.blood = blood;
this.gender=gender;
setFace(gender);
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return blood
*/
public int getBlood() {
return blood;
}
/**
* 设置
* @param blood
*/
public void setBlood(int blood) {
this.blood = blood;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getFace() {
return face;
}
public void setFace(char gender) {
Random r = new Random();
if(gender=='男'){
int index=r.nextInt(boyfaces.length);
this.face = boyfaces[index];
} else if (gender=='女') {
int index=r.nextInt(girlfaces.length);
this.face = girlfaces[index];
}else{
this.face="面目狰狞";
}
}
public void showinfo(){
System.out.println(getName());
System.out.println(getGender());
System.out.println(getFace());
}
public void attack(Role role){
Random r=new Random();
//输出攻击的招式
int index=r.nextInt(attacks_desc.length);
System.out.printf(attacks_desc[index],this.name,role.getName());
System.out.println();
//随机1-20的伤害
int hurt=r.nextInt(20)+1;
//计算剩余血量
int remainBlood=role.getBlood()-hurt;
//血量不能为负数
remainBlood = (remainBlood < 0) ? 0 : remainBlood;
//修改挨揍的人的血量
role.setBlood(remainBlood);
// //this表示方法的调用者，也就是发起攻击的人，传递进来的参数role是挨揍的人
// System.out.println(this.getName()+"打了"+role.getName()+"一拳，造成了"+hurt+"点的伤害，"+role.getName()+"还剩"+remainBlood+"点血");
//受伤的文字内容
if (remainBlood>90){
System.out.printf(injureds_desc[0],role.getName());
} else if (remainBlood > 80 && remainBlood <= 90) {
System.out.printf(injureds_desc[1],role.getName());
}else if (remainBlood > 70 && remainBlood <= 80) {
System.out.printf(injureds_desc[2],role.getName());
}else if (remainBlood > 60 && remainBlood <= 70) {
System.out.printf(injureds_desc[3],role.getName());
}else if (remainBlood > 50 && remainBlood <= 60) {
System.out.printf(injureds_desc[4],role.getName());
}else if (remainBlood > 30 && remainBlood <= 50) {
System.out.printf(injureds_desc[5],role.getName());
}else if (remainBlood > 20 && remainBlood <= 30) {
System.out.printf(injureds_desc[6],role.getName());
}else{
System.out.printf(injureds_desc[7],role.getName());
}
System.out.println();
}
}
10.2 对象数组
package homework;
import java.util.Scanner;
public class carTest {
public static void main(String[] args) {
car[] arr=new car[3];
//录入汽车的信息
Scanner sc=new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
car c=new car();
System.out.println("请输入汽车品牌");
c.setBrand(sc.next());
System.out.println("请输入汽车价格");
c.setPrice(sc.nextInt());
System.out.println("请输入汽车颜色");
c.setColor(sc.next());
//下面这行是难点，第一次写的时候没想出来
arr[i]=c;
}
//输出汽车的信息
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i].getBrand()+arr[i].getPrice()+arr[i].getColor());
}
}
}
package homework;
public class car {
private String brand;
private double price;
private String color;
public car() {
}
public car(String brand, double price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
/**
* 获取
* @return brand
*/
public String getBrand() {
return brand;
}
/**
* 设置
* @param brand
*/
public void setBrand(String brand) {
this.brand = brand;
}
/**
* 获取
* @return price
*/
public double getPrice() {
return price;
}
/**
* 设置
* @param price
*/
public void setPrice(double price) {
this.price = price;
}
/**
* 获取
* @return color
*/
public String getColor() {
return color;
}
/**
* 设置
* @param color
*/
public void setColor(String color) {
this.color = color;
}
}
package homework;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
/**
* 获取
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
}
package homework;
public class StudentTest {
public static void main(String[] args) {
Student[] arr = new Student[3];
Student s1=new Student(1,"张三",18);
Student s2=new Student(2,"李四",19);
Student s3=new Student(3,"王五",20);
arr[0]=s1;
arr[1]=s2;
arr[2]=s3;
//再添加一个学生变量
Student s4=new Student(4,"赵六",21);
//判断唯一性
boolean flag=contain(arr,s4.getId());
if(flag){
System.out.println("此学生id已经存在");
}else{
//当id不存在时就进行添加
//判断数组是否存满
int count=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]!=null){
count++;
}
}
if(arr.length==count){
//当数组已经存满,需要创建一个新的数组
Student[] arr1=new Student[arr.length+1];
for (int i = 0; i < arr.length; i++) {
arr1[i]=arr[i];//将数组中的元素复制过去
}
arr1[count]=s4;
printarr(arr1);
}else{
//当数组没存满
arr[count]=s4;
printarr(arr);
}
}
}
//唯一性判断
public static boolean contain(Student[] arr,int id){
for (int i = 0; i < arr.length; i++) {
if(arr[i]!=null){
if(arr[i].getId()==id){
return true;
}
}
}return false;
}
//遍历数组
public static void printarr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
if(arr[i]!=null){
Student s=arr[i];
System.out.println("学号："+s.getId()+"，姓名："+s.getName()+"，年龄："+s.getAge());
}
}
}
}
package homework;
public class StudentDeleteTest {
public static void main(String[] args) {
Student[] arr = new Student[3];
Student s1=new Student(1,"张三",18);
Student s2=new Student(2,"李四",19);
Student s3=new Student(3,"王五",20);
arr[0]=s1;
arr[1]=s2;
arr[2]=s3;
//再添加一个学生变量
Student s4=new Student(2,"赵六",21);
//寻找索引
int index=findindex(arr,s4.getId());
if(index>=0){
//查找到了以后年龄+1后输出
arr[index].setAge(arr[index].getAge()+1);
System.out.println(arr[index].getId()+"，"+arr[index].getName()+"，"+arr[index].getAge());
//存在则删除
arr[index]=null;
System.out.println("此学生id已经存在,现已删除");
printarr(arr); //遍历数组
}else{
//当id不存在时
System.out.println("不存在，删除失败");
}
}
//寻找相同id的索引
public static int findindex(Student[] arr,int id){
for (int i = 0; i < arr.length; i++) {
Student s=arr[i];
if(s.getId()==id){
return i;
}
}return -1;
}
//遍历数组
public static void printarr(Student[] arr){
for (int i = 0; i < arr.length; i++) {
if(arr[i]!=null){
Student s=arr[i];
System.out.println("学号："+s.getId()+"，姓名："+s.getName()+"，年龄："+s.getAge());
}
}
}
}
11、API和API帮助文档
点击显示—>索引—>查询
12、字符串
12.1 string概述
* 格式化代码快捷键ctrl+alt+L ，自动生成左边变量接收ctrl+alt+v
* next(), nextInt(), nextDouble() 等方法的区别
当涉及到处理输入时，这些方法通常用于从用户提供的输入中获取下一个值。在Java中，这些方法通常与Scanner类一起使用。
-
next():
next()方法用于读取下一个以空格分隔的字符串。- 例如，如果输入为 "Hello World"，那么使用
next()方法将只读取 "Hello"，而不会读取 "World"。
-
nextInt():
nextInt()方法用于读取下一个整数值。- 例如，如果输入为 "123 456"，那么使用
nextInt()方法将读取整数值 123。
-
nextDouble():
nextDouble()方法用于读取下一个双精度浮点数值。- 例如，如果输入为 "3.14 2.71828"，那么使用
nextDouble()方法将读取双精度浮点数值 3.14。
12.2 string构造方法代码实现和内存分析
12.3 字符串的比较
12.4 练习：用户登录
package homework;
import java.util.Scanner;
public class login {
public static void main(String[] args) {
String user = "zhangsan";
String password = "123456";
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入用户名");
String user1 = sc.next();
System.out.println("请输入密码");
String password1 = sc.next();
if (user.equals(user1) && password.equals(password1)) {
System.out.println("登录成功");
break;
} else if (i<2) {
System.out.println("登录失败，请重新输入，还有"+(2-i)+"次机会");
}else{
System.out.println("登录失败，请联系客服处理");
}
}
}
}
12.5 遍历字符串
统计大小写字母和数字个数：
* 倒序遍历
可以自己把length改成i，便于阅读和理解
12.6 字符串拼接和反转
* 插入循环快捷键ctrl+alt+t
12.7 练习：金额转换
如2153转换为零佰零拾零万贰仟壹佰伍拾叁元
package homework;
import java.util.Scanner;
public class MoneyConvert {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int money;
//限制金额的位数
while (true) {
System.out.println("请输入金额：");
money = sc.nextInt();
if (money >= 0 && money <= 9999999) {
break;
}
}
int ge;
String money1 = "";
//转换成中文大写
while (money!=0) {
ge = money % 10;
money=money/10;
money1 = convert(ge) + money1;
}
// System.out.println(money1);
//补零成7位数
int count=7-money1.length();
for (int i = 0; i < count; i++) {
money1='零'+money1;
}
// System.out.println(money1);
//插入单位
String money2="";
char[] s={'佰','拾','万','仟','佰','拾','元'};
for (int i = 0; i < 7; i++) {
money2=money2+money1.charAt(i)+s[i];
}
System.out.println(money2);
}
public static char convert(int ge) {
char[] str = {'零','壹','贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'};
return str[ge];
}
}
12.8 字符串截取substring、charAt
如果要截取单个字符，可以使用12.5中所述的charAt
12.9 练习：手机号屏蔽
* 查询字符ASCII的小技巧
* 字符型的数字转换成int类型的方法
12.10 字符串替换replace
12.11 StringBuilder
常用场景：1、字符串拼接；2、字符串反转
链式编程：不需要用变量接收它的结果，可以继续调用其他方法
例如：
12.12 练习：判断是否为对称字符串
12.13 练习：拼接字符串
package homework;
public class pinjie {
public static void main(String[] args) {
int[] str={1,2,3,4,5,6,7};
String result=IntToString(str);
System.out.println(result);
}
public static String IntToString(int[] str){
StringBuilder sb=new StringBuilder();
sb.append("[");
for (int i = 0; i < str.length; i++) {
if(i==str.length-1){
sb.append(str[i]).append("]");
}else{
sb.append(str[i]).append(", ");
}
}
return sb.toString();//StringBuilder是一个容器，因此需要转换成字符串形式返回
}
}
12.14 StringJoiner
add只能添加字符串类型
12.15 字符串相关类的底层原理
* 查询源码快捷键ctrl+n
右上角选择all places
* 常见面试题
12.16 练习题：转换罗马数字
package homework;
import java.util.Scanner;
public class luoma {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str;
//输入和判断
while (true) {
System.out.println("请输入一个字符串");
str = sc.next();
if (CheckStr(str)) {
break;//符合要求退出循环
} else {
System.out.println("不符合要求，请重新输入");
}
}
//转换
StringBuilder sb=new StringBuilder();
for (int i = 0; i < str.length(); i++) {
sb.append(changeLuoma(str.charAt(i)-48));//-48将字符转换成数字
}
System.out.println(sb);
}
//校验字符是否符合规定
public static boolean CheckStr(String str) {
if (str.length() > 9) {
return false;
}
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (c < '0' || c > '9') {
return false;
}
}
return true;
}
//转换成罗马
public static String changeLuoma(int number) {
String[] luoma = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
return luoma[number];
}
}
12.17 练习题：调整字符串
package homework;
public class changeStr {
public static void main(String[] args) {
String strA="abcde";
String strB="bcdea";
boolean result=check(strA,strB);
System.out.println(result);
}
//判断是否符合
public static boolean check(String str1,String str2){
for (int i = 0; i < str1.length(); i++) {
str1=rotate(str1);
if(str1.equals(str2)){
return true;
}
}return false;
}
//旋转字符串
public static String rotate(String str){
char first=str.charAt(0);
String end=str.substring(1);
return end+first;
}
}
以上是方法1，下面是方法2：
* 将字符串变成字符数组toCharArray
* 利用字符数组创建字符串对象（详见图末尾）
12.18 练习题：键盘输入任意字符串，打乱里面的内容
package homework;
import java.util.Random;
import java.util.Scanner;
public class randomStr {
public static void main(String[] args) {
System.out.println("请输入需要打乱的字符串：");
Scanner sc = new Scanner(System.in);
String str = sc.next();
//变成字符数组
char[] arr = str.toCharArray();
//随机打乱
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int index = r.nextInt(arr.length);
char temp= arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
String result = new String(arr);
System.out.println(result);
}
}
12.19 练习题：随机验证码，要求4字母1数字
package homework;
import java.util.Random;
public class randomYanzheng {
public static void main(String[] args) {
char[] arr = new char[52];
for (int i = 0; i < arr.length; i++) {
if (i < 26) {//小写字母,强制转换
arr[i] = (char) (97 + i);
} else {//大写字母
arr[i] = (char) (65 + i - 26);
}
}
String YanZheng = "";
Random r = new Random();
for (int i = 0; i < 4; i++) {
int index = r.nextInt(arr.length);
YanZheng = YanZheng + arr[index];
}
int number=r.nextInt(10);
YanZheng=YanZheng+number;
// System.out.println(YanZheng);
//乱序
char[] arr1 = YanZheng.toCharArray();
for (int i = 0; i < arr1.length; i++) {
int randomIndex=r.nextInt(arr1.length);
char temp=arr1[i];
arr1[i]=arr1[randomIndex];
arr1[randomIndex]=temp;
}
String result=new String(arr1);
System.out.println(result);
}
}
12.20 练习题：将两个内容为非负数字的字符串相乘，结果返回字符串
package homework;
public class StringToNum {
public static void main(String[] args) {
String num1 = "12345";
String num2 = "67890";
char[] arr1 = num1.toCharArray();
char[] arr2 = num2.toCharArray();
int number1 = 0;
int number2 = 0;
for (int i = 0; i < arr1.length; i++) {
int ge = arr1[i] - 48;
number1 = number1 * 10 + ge;
}
for (int i = 0; i < arr2.length; i++) {
int ge = arr2[i] - 48;
number2 = number2 * 10 + ge;
}
int resultNum = number1 * number2;
String result = resultNum + "";
System.out.println(result);
}
}
12.21 练习题：返回字符串中最后一个单词的长度
package homework;
public class LastWordLength {
public static void main(String[] args) {
String arr="fly me to the moon";
char[] arr1=arr.toCharArray();
int count=0;
for (int i = arr1.length-1; i >= 0; i--) {
if(arr1[i]!=' '){
count++;
}else{
break;
}
}
System.out.println("最后一个单词的长度为"+count);
}
}
12.22 练习题：统计字符串中英文字母和数字分别有多少个
package StringHomework;
import java.util.Scanner;
public class CountLetterNum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
line = line.toLowerCase(); // 为方便统计，将字符串中的字母都转为小写
int Letcount = 0;
int NumCount = 0;
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
if (c>='a'&&c<='z'){
Letcount++;
} else if (c>='0'&&c<='9') {
NumCount++;
}
}
System.out.println("字母："+Letcount+"个");
System.out.println("数字："+NumCount+"个");
}
}
12.23 练习题：判断一个字符串是否是对称的字符串
package StringHomework;
public class HuiwenString {
public static void main(String[] args) {
String str="上海自来水来自海上";
System.out.println(check(str));
}
public static boolean check(String str){
if(str==null){
return false;
}
StringBuilder sb=new StringBuilder(str);
String str1=sb.reverse().toString();
return str1.equals(str);
}
}
12.24 练习题：判断用户输入的身份证号码是否合法
规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。
package StringHomework;
import java.util.Scanner;
public class CheckIDCard {
public static void main(String[] args) {
System.out.println("请输入身份证号:");
Scanner sc=new Scanner(System.in);
String ID=sc.next();
System.out.println(check(ID));
}
public static boolean check(String str){
if(str==null){
return false;
}
if(str.length()!=18){
return false;
}
if(str.charAt(0)=='0'){
return false;
}
for (int i = 0; i < str.length()-1; i++) {
char c=str.charAt(i);//前17位
if(c<'0'||c>'9'){
return false;
}
}
if(str.charAt(17)=='X'||(str.charAt(17)>='0'&&str.charAt(17)<='9')){
return true;
}else{
return false;
}
}
}
12.25 练习题：统计该文本中"Java"一词出现的次数
public class Test {
public static void main(String[] args) {
String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
String tar = "Java";
// 调用方法并输出
System.out.println(search(str, tar));
}
// 返回值int表示次数，参数列表str表示在哪个字符串中查找，tar表示要查找的目标子串
public static int search(String str, String tar) {
// 定义统计变量表示次数
int count = 0;
// 定义索引变量，表示每次找到子串出现的索引
int index = -1;
// 定义循环，判断条件为在字符串中找到了目标子串
while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
// 次数累加
count++;
// 把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取。
str = str.substring(index + tar.length());
}
return count;
}
}
public class Test {
public static void main(String[] args) {
String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
String tar = "Java";
// 调用方法并输出
System.out.println(search(str, tar));
}
// 替换之后求长度差
public static int search(String str, String tar) {
String newStr = str.replace(tar, "");
int count = (str.length() - newStr.length()) / tar.length();
return count;
}
}
13、集合
13.1 集合的基本使用
13.2 添加字符串和整数并遍历
* 基本数据类型对应的包装类
要想在集合中放基本数据类型，需要改为包装类
13.3 添加学生对象并遍历的两个练习
package listPractice;
import java.util.ArrayList;
public class bianliStudent {
public static void main(String[] args) {
ArrayList<Student> list=new ArrayList<>();
Student stu1=new Student("张三",18);
Student stu2=new Student("李四",19);
Student stu3=new Student("王五",20);
list.add(stu1);
list.add(stu2);
list.add(stu3);
for (int i = 0; i < list.size(); i++) {
Student s=list.get(i);
System.out.println("姓名："+s.getName()+", 年龄："+s.getAge());
}
}
}
package listPractice;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
改成手动录入：
package listPractice;
import java.util.ArrayList;
import java.util.Scanner;
public class bianliStudent1 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Scanner sc=new Scanner(System.in);
for (int i = 0; i < 3; i++) {
Student stu=new Student();
System.out.println("请输入姓名：");
String name=sc.next();
System.out.println("请输入年龄：");
int age=sc.nextInt();
//传递参数
stu.setName(name);
stu.setAge(age);
//放到集合里
list.add(stu);
}
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println("姓名：" + s.getName() + ", 年龄：" + s.getAge());
}
}
}
13.4 练习题：寻找该学生对象名是否存在
package listPractice;
import java.util.ArrayList;
public class CheckContain {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student stu1 = new Student("张三", 18);
Student stu2 = new Student("李四", 19);
Student stu3 = new Student("王五", 20);
list.add(stu1);
list.add(stu2);
list.add(stu3);
boolean result = check(list, "张三");
System.out.println(result);
}
public static boolean check(ArrayList<Student> list, String name) {
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getName().equals(name)) {
return true;
}
}
return false;
}
}
结果为true
13.5 练习题：筛选手机信息
判断的方法：
主函数里调用方法：
13.6 项目练习：学生管理系统
package Manage;
import java.util.ArrayList;
import java.util.Scanner;
public class StudentManage {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
loop:
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 sc = new Scanner(System.in);
String choice = sc.next();
switch (choice) {
case "1" -> {
System.out.println("请输入要添加的学生id");
String id = sc.next();
addStudent(list, id);
}
case "2" -> {
System.out.println("请输入要删除的学生id");
String id = sc.next();
deleteStudent(list, id);
}
case "3" -> {
System.out.println("请输入要修改的学生id");
String id = sc.next();
reviseStudent(list, id);
}
case "4" -> {
System.out.println("请输入要查询的学生id");
String id = sc.next();
searchStudent(list, id);
}
case "5" -> {
System.out.println("退出");
break loop;
}
default -> System.out.println("没有这个选项，请重新输入");
}
}
}
//添加学生
public static void addStudent(ArrayList<Student> list, String id) {
//判断id是否已经存在
//如果存在
if (contain(list, id)) {
System.out.println("当前id已存在");
} else {//不存在
Scanner sc = new Scanner(System.in);
System.out.println("请输入姓名：");
String name = sc.next();
System.out.println("请输入年龄：");
int age = sc.nextInt();
System.out.println("请输入地址：");
String address = sc.next();
Student s = new Student(id, name, age, address);
list.add(s);
}
}
//删除学生
public static void deleteStudent(ArrayList<Student> list, String id) {
int index = containIndex(list, id);
if (index == -1) {//当前id不存在
System.out.println("当前id不存在");
}else{
list.remove(index);
System.out.println("删除成功");
}
}//修改学生
public static void reviseStudent(ArrayList<Student> list, String id) {
int index = containIndex(list, id);
if (index == -1) {//当前id不存在
System.out.println("当前id不存在");
}else{
Scanner sc=new Scanner(System.in);
System.out.println("请输入新姓名：");
String newName=sc.next();
list.get(index).setName(newName);
System.out.println("请输入新年龄：");
int newAge=sc.nextInt();
list.get(index).setAge(newAge);
System.out.println("请输入新地址：");
String newAddress=sc.next();
list.get(index).setAddress(newAddress);
}
}//查询学生
public static void searchStudent(ArrayList<Student> list, String id) {
int index = containIndex(list, id);
//如果存在
if (index > -1) {
System.out.println("id：" + list.get(index).getId() + "\t姓名：" + list.get(index).getName() + "\t年龄：" + list.get(index).getAge() + "\t地址：" + list.get(index).getAddress());
}else{
System.out.println("当前学生id不存在");
}
}
//是否存在
public static boolean contain(ArrayList<Student> list, String id) {
return containIndex(list, id) > -1;
}
//是否存在，返回索引
public static int containIndex(ArrayList<Student> list, String id) {
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getId().equals(id)) {
return i;
}
}
return -1;
}
}
鼠标点击后ALT+回车自动创建方法
* startwith
14、面向对象进阶
14.1 static静态变量
14.2 静态方法和工具类
静态方法写好以后可以调用，哪个包需要就粘贴过去用
14.3 static的注意事项
这里的name会报错，因为name不是静态变量
show方法不是静态，会报错
* main方法
14.4 继承的概述
java三大特性：封装、继承、多态
14.5 继承的特点与继承体系的设计
后面都类似，不列举了
14.6 子类到底能继承父类的哪些内容
14.7 继承中成员方法和成员变量访问的特点
* 重写
14.8 继承中的构造方法和this、supper关键字
14.9 认识多态
14.10 多态中调用成员的特点
14.11 多态的优势和弊端
elseif里面的狗改为猫
14.12 包和final
14.13 权限修饰符和代码块
14.14 抽象类和抽象方法
14.15 接口
14.16 内部类
15、常用API
* 练习题：找出文本中所有的JAVAXX
15.1 JDK7时间
15.2 包装类
16、常见算法
16.1 查找
16.2 排序
16.3 递归
16.4 Arrays
16.5 lambda
17 集合进阶
快捷键：
18 双列集合、map
19 方法引用
20 异常
扫一扫
2071
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
