JAVA基础上-CSDN博客

本文链接：https://blog.csdn.net/m0_73852099/article/details/140063055

文章目录

JAVA入门
流程控制语句
- 分类
数组

JAVA入门

JAVA语言的发展

三个版本
Java5.0:Java的第一个大版本更新
Java8.0:目前绝大多数公司正在使用的版本，最稳定
Java15.0:学习使用版本

Java的三大平台

JavaSE、JavaME、JavaEE
JavaSE
是JavaME和JavaEE版本的基础
JavaME
java语言的小型版，用于嵌入式消费类电子设备或者小型移动设备的开发，最主要的是小型移动设备的开发，后被安卓和IOS代替，安卓也可以用java开发。
JavaEE
用于Web方向的网站开发，主要从事后台服务器的开发。

Java的主要特性

面向对象
安全性强
多线程
简单易用
开源
跨平台

Java语言跨平台的原理

针对不同的操作系统，java提供了不同的虚拟机，一次编译，处处可用。
javac把java程序编译成.class文件，Windows/Linux/MacOS版JVM虚拟机把.class文件翻译成Windows/Linux/MacOS操作系统能看懂的语言。
JRE和JDK
JDK包括JVM、核心类库和开发工具
JRE包括JVM、核心类库和运行工具
JVM(Java Virtual Machine ),Java虚拟机
JRE(Java Runtime Environment),Java运行环境，包括了JVM和Java的核心类库（Java API）
JDK(Java Develop Kit):Java开发工具，包含了JRE和开发工具。
只需要安装jdk即可，包含了java的运行环境和虚拟机

流程控制语句

分类

顺序结构
判断和选择结构（if和switch）
循环结构（for,while,do…while）

顺序结构

流程图

判断语句：if语句

if语句格式1
执行流程

//练习1：键盘录入女婿的酒量，如果大于2斤，老丈人给出回应，否则没有任何回应
//键盘录入女婿的酒量
Scanner sc=new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine =sc.nextInt();
if(wine>2){
System.out.println("不错");
}

//练习2：键盘录入一个整数，表示小明的考试名次，如果名次为1，小红可以当小明的女朋有了。
//键盘录入一个整数，表示小明的考试次
Scanner sc=new Scanner(System.in);
System.out.println("请输入小明的名次：");
int rank=sc.nextInt();
//对小明的成绩进行判断即可
if(rank==1){
System.out.println("小红成为了小明的女朋友  ");
}

if语句格式2

执行流程

// 键盘录入一个整数，表示身上的钱。如果大于等于100块，就是网红餐厅。否则，就吃经济实惠的沙县小吃。
//键盘录入一个整数，表示身上的钱
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数表示身上的钱");
int money=sc.nextInt();
//对钱进行判断
if(money>=100){
System.out.println("吃网红餐厅");
}else{
System.out.println("福建大酒店");
}

//在实际开发中，电影院选座也会使用到if判断。假设某影院售卖了100张票，票的序号为1~100。其中奇数票号坐左侧，偶数票号坐右侧。键盘录入一个整数表示电影票的票号。根据不同情况，给出不同的提示：如果票号为奇数，那么打印坐左边。如果票号为偶数，那么打印坐右边。
Scanner sc=new Scanner(System.in);
System.out.println("请输入票号");
int ticket =sc.nextInt();
if(ticket>=1&&ticket<=100){
    if(ticket%2==0){
     System.out.println("坐右边");
    }else{
     System.out.println("坐左边");
    }
}else{
  System.out.println("票号不合法");
}

if语句格式3
执行流程

//	小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，95~100 自行车一辆,90~94   游乐场玩一天 80 ~ 89 变形金刚一 80 以下  胖揍一顿
Scanner sc=new Scanner(System.in);
System.out.println("请输入小明的成绩");
int score = sc.nextInt();
if(score >=0 && score<=100){
     if(score >=95 && score<=100){
           System.out.println("送自行车一辆");
     }else if(score >= 90 && score <= 94)  
       {
          System.out.println("游乐场玩一天");
       }else if(score >= 80 && score <= 89){
           System.out.println("变形金刚一个");
       }else{
             System.out.println("胖揍一顿");
       }
     
}

switch语句

//需求：键盘录入星期数，显示今天的减肥活动。周一：跑步 周二：游泳  周三：慢走  周四：动感单车 周五：拳击 周六：爬山  周日：好好吃一顿
//1.键盘录入一个整数表示星期
Scanner sc=new Scanner(System.in);
  System.out.println("请输入一个整数表示星期几");
  int weekday=sc.nextInt();
  switch(weekday){
      case 1:
          System.out.println("跑步");
          break;
      case 2:
          System.out.println("游泳");
          break;
      case 3:
          System.out.println("慢走");
          break;
      case 4:
           System.out.println("动感单车");
           break;
      case 5:
           System.out.println("拳击");
           break;
      case 6:
           System.out.println("爬山");
           break;
      case 7:
          System.out.println("好好吃一顿");
           break;
      default:
         System.out.println("输入错误，没有这个星期");
        break; 
  }

default的位置和省略情况

default可以放在任意位置，也可以省略
case穿透

不写break会引发case穿透现象
switch在JDK12的新特性

int number=10;
switch(number){
    case 1 -> System.out.println("一");
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}

switch和if第三种格式各自的使用场景
当我们需要对一个范围进行判断的时候，用if的第三种格式
当我们把有限个数据列举出来，选择其中一个执行的时候，用switch语句
比如：
小明的考试成绩，如果用switch，那么需要写100个case，太麻烦了，所以用if简单。
如果是星期，月份，客服电话中0~9的功能选择就可以用switch

//练习：键盘录入星期数，输出工作日、休息日。(1-5) 工作日，(6-7)休息日。
//1.键盘录入星期数
Scanner sc=new Scanner(System.in);
int weekday=sc.nextInt();
//2.利用switch进行匹配
switch(weekday){
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
          System.out.println("工作日");
          break;
      case 6:
      case 7:
          System.out.println("工作日");
          break;
       default:
        System.out.println("没有这个星期");
        break;
}

//利用JDK12简化代码书写
switch(weekday){
    case 1,2,3,4,5->System.out.println("工作日");
    case 6,7 ->System.out.println("休息日");
    default ->System.out.println("没有这个星期");
}

循环结构

//需求：在控制台输出1-5和5-1的数据 
for(int i=1;i<=5;i++){
    System.out.println(i);
}
//需求：输出数据5-1
for(int i=5;i>=1;i--){
    System.out.println(i);
}
//需求：求1-5之间的数据和，并把求和结果在控制台输出
int sum=0;
for(int i=1;i<=5;i++){
   sum=sum+i;
}
System.out.println(sum);

//需求：求1-100之间的偶数和，并把求和结果在控制台输出
int sum=0;
for(int i=1;i<=100;i++){
   if(i%2==0){
       sum=sum+i;
   }
}
System.out.println(sum);

//需求：键盘录入两个数字，表示一个范围。统计这个范围中。既能被3整除，又能被5整除数字有多少个？
Scanner sc=new Scanner(System.in);
int num1=sc.nextInt();
int num2=sc.nextInt();
int count=0;
int num3=num1<num2?num1:num2;
int num4=num1>num2?num1:num2;
for(int i=num3;i<=num4;i++){
    if((i%3==0)&&(i%5==0)){
        count++;
    }
}
System.out.println(count);

while循环

//打印5次HelloWorld
 int i=1;
 while(i<=5){
    System.out.println("Helloworld");
    i++;
 }
//珠穆朗玛峰
//1.定义一个变量表示珠穆朗玛峰的高度
int height=8844430;
//2.定义一个变量表示纸张的厚度
double paper=0.1;
//定义一个计数器（变量），用来统计折叠的次数
int count=0;
//3.循环折叠纸张
//只有纸张的厚度 < 穆朗玛峰的高度 循环才继续，否则循环就停止
//坑：只有判断为真，循环才会继续
while(paper<height){
  paper=paper*2;
  count++;
}
//4.打印一下纸张的厚度
Sysrem.out.println(count);

do…while循环

初始化语句;
do{
循环体;
条件控制语句;
}while(条件判断语句);
特点：先执行，再判断。

三种格式的区别

for和while循环，是先判断再执行
do…while是先执行，再判断
当知道循环次数或者循环范围的时候用for循环
当不知道循环次数，也不知道循环范围，但知道循环的结束条件时，用while循环。

数组

概念

指的是一种容器，可以同来存储同种数据类型的多个值。但是数组容器在存储数据的时候，需要结合隐式转换考虑。
建议：容器的类，和存储的数据类型保持一致。

数组的定义

格式一：数据类型[] 数组名
格式二：数据类型数组名[]
数据类型：限定了数组以后能存什么类型的数据。
方括号：表示现在定义的是一个数组。
数组名：就是一个名字而已，方便以后使用。

数组的静态初始化

完整格式：
数据类型[] 数组名=new 数据类型[]{元素1，元素2，元素3，元素4…}；
比如：
int[] arr=new int[]{11,22,33};
double[] arr=new double[]{1.1,1.2,1.3};
格式详解：
数据类型： 限定数组以后能存什么类型的数据
方括号： 表示现在定义的是一个数组
数组名： 自取的名字，方便以后使用
new: 就是数组在内存中开辟了一个空间
数据类型： 限定了数组以后能存什么类型的数据。前面和后面的数据类型一定要保持一致。
方括号： 表示现在定义的是一个数组。
大括号： 表示数组里面的元素，元素也就是存入到数组中的数据，多个元素之间一定要用逗号隔开。
注意点
等号前后的数据类型必须保持一致，数组一旦创建完成，长度不能发生变化。
简化格式：
数据类型[] 数组名={元素1，元素2，····};

//定义数组存储5个学生的年龄。
int[] agesArr=new int[]{18,29,20,21,22};
int[] agesArr={18,29,20,21,22};

//定义数组存储
String[] nameArr=new String[]{"zhangsan","lisi","wangwu"};
String[] nameArr={"zhangsan","lisi","wangwu"};

//定义数组存储4个学生的身高。
double[] height=new double[]{1.85,1.82,1.78,1.65};
double[] height={1.85,1.82,1.78,1.65};

地址值

打印数组的时候，实际出现的是数组的地址值，数组的地址值表示数组在内存中的位置。

int[] arr={1,2,3,4,5};
System.out.println(arr);//[I@6d03e736
double[] arr1={1.1,2.3,3.4,5.6};
System.out.println(arr1);//[D@568db2f2

[D@568db2f2:
[:表示打印的是一个数组
D：表示打印的数组是double类型的
@:仅仅是一个间隔符号
568db2f2:数组在内存中真正的地址值（十六进制）

数组元素的访问

int[] arr={1,2,3,4,5};
//需求1：获取arr数组中，3索引上的值
int number=arr[3];
 System.out.println(number);
 System.out.println(arr[3]);
//需求2：将arr数组中，3索引上的值修改为10
arr[3] = 10;
System.out.println("修改之后为:" + arr[3]);

索引

一定从0开始。连续不间断，逐个加一增长

数组的遍历

数组的长度：数组名.length

for(int i=0;i<arr.length;i++){
  System.out.println(arr[i]);
}

数组的动态初始化

格式：
数据类型[] 数组名=new 数据类型[数组长度];

int[] agesArr=new int[3];
int[] scores=new int[10];

数组的默认初始化值

int :0
float/double:0.0
boolean:false
char:‘\u0000’
引用类型:null

数组两种初始化方式的区别

静态初始化：int[] arr={1,2,3,4,5};
动态初始化:int[] arr=new int[12];
静态初始化:手动指定数组的元素，系统根据数组元素的个数计算数组的长度。
动态初始化：手动指定数组的长度，由系统给出默认初始化值。

数组常见问题

当访问了数组中不存在的索引，就会引发索引越界异常。一个数组中最小索引是0，最大索引是数组名.length-1

int[] arr={1,2,3,4,5,5,5,5,5};
System.out.println(arr[1]);
System.out.println(arr[10]);//ArrayIndexOutOfBoundsException

数组的练习

//定义一个数组，存储1,2,3,4,5,遍历数组得到每一个元素，求数组里面所有的数据和
int[] arr={1,2,3,4,5};
int sum=0;
for(int i=0;i<arr.length;i++){
 sum=sum+arr[i];
}
System.out.println(sum);

//定义一个数组，存储1,2,3,4,5,6,7,8,9,10,遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
int[] arr={1,2,3,4,5,6,7,8,9,10};
int count=0;
for(int i=0;i<arr.length;i++){
   if(arr[i]%3==0){
      System.out.println(arr[i]);
      count++;
   }
}
System.out.println(count);
//需求：定义一个数组，存储1,2,3,4,5,6,7,8,9,10遍历数组得到每一个元素。要求：1，如果是奇数，则将当前数字扩大两倍 2，如果是偶数，则将当前数字变成二分之一
int[] arr={1,2,3,4,5,6,7,8,9,10};
for(int i=0;i<arr.length;i++){
  if(arr[i]%2==0){
      arr[i]=arr[i]/2;
  }else{
        arr[i]=arr[i]*2;
  }
}
for(int i=0;i<arr.length;i++){
  System.out.println(arr[i]);
}

//需求：求数组中的最大值
int[] arr={33,5,22,44,55};
int max=arr[0];
for(int i=1;i<arr.length;i++){
    if(arr[i]>max){
        max=arr[i];
    }
}
System.out.println(max);

//统计个数
//需求：生成10个1~100之间的随机数存入数组。1）求出所有数据的和 2）求所有数据的平均数 3）统计有多少个数据比平均值小
int[] arr=new int[10];
Random r=new Random();
for(int i=0;i<arr.length;i++){
   int number=r.nextInt(100)+1;
   arr[i]=number;
}
int sum=0;
for(int i=0;i<arr.length;i++){
  sum=sum+arr[i];
}
System.out.println("数组中所有数据的和为：" + sum);
//求所有数据的平均数
int avg=sum/arr.length;
System.out.println("数组中平均数为：" + avg);
//统计有多少个数据比平均值小
int count=0;
for(int i=0;i<arr.length;i++){
   if(arr[i]<avg){
       count++;
   }
}
System.out.println("在数组中，一共有" + count + "个数据，比平均数小");
//遍历数组，验证答案
for(int i=0;i<arr.length;i++){
   System.out.print(arr[i] + " ");
}

//需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。交换前：1,2,3,4,5 交换后：5 4 3 2 1 
int[] arr={1,2,3,4,5};
for(int i=0,j=arr.length-1;i<j;i++,j--){
       int temp=arr[i];
       arr[i]=arr[j];
       arr[j]=temp;
}
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

//定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。
int[] arr={1, 2, 3, 4, 5};
Random r=new Random();
for(int i=0;i<arr.length;i++){
     int index=r.nextInt(arr.length);
     int temp=arr[i];
     arr[i]=arr[index];
     arr[index]=temp;
}
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

无限循环

//for格式
for(;;){
System.out.println("无限循环");
}
//while格式
while(true){
System.out.println("无限循环");
}
//do...while格式
do{
System.out.println("无限循环");
}while(true);

无限循环的下面不能写代码，因为永远执行不到

条件控制语句

break
continue
break不能单独存在，可以用在switch和循环中，表示结束，跳出的意思。

//1.吃1~5号包子
for(int i=1;i<=5;i++){
  System.out.println("在吃第"+i+"个包子");
  //只吃到第三个包子，剩下的不吃
  if(i==3){
     break;//结束整个循环
  }
}

continue不能单独存在，只能存在于循环当中，表示跳过本次循环，继续执行下次循环

for(int i=1;i<=5;i++){
//表示不吃第三个包子，继续吃其他包子
  if(i==3){
  //跳过本次循环，继续执行下次循环
    continue;
  }
}

Random

使用前需要导包
import java.util.Random
创建对象
Random r=new Random();
生成随机数
int number=r.nextInt(随机数值);
从0开始，生成范围为[0,随机数值)

//游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过 使用程序在控制台打印出1-100之间的满足逢七必过规则的数据 
for(int i=1;i<=100;i++){
  if(i%7==0){
     System.out.println("过");
     continue;//如果不加continue，则只会输出一个过,加上continue表示这个数结束后继续遍历剩下的数字
   }
     System.out.println(i);
}

//键盘录入一个大于等于2的整数 x ，计算并返回 x 的平方根 。结果只保留整数部分,小数部分将被舍去 。
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
for(int i=1;i<=num;i++){
   if(i*i==number){
      System.out.println(i+"是"+num+"的平方根");
      break;//一旦找到，循环就可以停止
   }else if(i*i>num){
     System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
        break;
   }
}
//键盘录入一个正整数 x ，判断该整数是否为一个质数。 
//如果一个整数只能被1和本身整除，那么这个数就是质数。否则这个数叫做合数
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
for(int i=2;i<num;i++){
    if(num %i==0){
        System.out.println(num+"不是质数");
        break;
    }else{
         System.out.println(num+"是质数");
     }
}

//程序自动生成一个1-100之间的随机数，在代码中使用键盘录入去猜出这个数字是多少？
Random r=new Random();
int num=r.nextInt(100)+1;
 System.out.println("系统给出的数字是"+num);
while(true){
  Scanner sc=new Scanner(System.in);
  int input=sc.nextInt();
  if(input<num){
    System.out.println("你当前输入数字过小");
   }else if(input>num){
     System.out.println("你当前输入数字过大");
  }else{
  System.out.println("恭喜你，输入数字正确");
  break;
  }
}

方法

形参和实参

形参是方法定义时的参数
实参是方法调用时的参数

方法的注意事项

方法不能嵌套定义
void表示没有返回值，可以省略return,也可以单独书写return,后面不加数据

public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;	
        //System.out.println(100); return语句后面不能跟数据或代码
    }

通用格式

public static 返回值类型方法名(参数名){
方法体；
return 数据;
}
*public static：*修饰符
*返回值类型:*方法操作完毕之后返回数据的数据类型，若最后没有数据返回，此处用void代替，方法体中不写return
*方法名：*调用方法时的标识
*return:*若方法操作完毕，有数据返回，用于把数据返回给调用者
定义方法时需要明确返回值类型和参数(类型和数量)
void方法直接调用即可，非void方法使用变量接收调用

方法重载

多个方法在同一个类中并且方法名称相同，但是方法的参数、类型或者数量不同
同一个类中的方法的名称和参数进行识别，与返回值无关，也就是说只要在同一个类中，方法名称相同，但是参数的名称、类型或者数量不同就可以视为重载，与返回值类型无关

//正确范例
public class MethodDemo{
public static void fn(int a){//方法体}
public static int fn(double a){//方法体}
public static float fn(int a) {
    	//方法体
    }
    public static int fn(int a , int b) {
    	//方法体
    }
}
//错误范例
public class MethodDemo {
	public static void fn(int a) {
    	//方法体
    }
    public static int fn(int a) { 	/*错误原因：此两个方法体的唯一区别在于返回值类型，而重载与返回值类型无关，故该两个方法称不上重载*/
    	//方法体
    }
}

public class MethodDemo01 {
    public static void fn(int a) {
        //方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { /*错误原因：重载需要在一个类中的方法，此两个方法不在同一个类中，故也称不上重载*/
        //方法体
    }
}
//：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long） 
public class MethodTest{
  public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }
}
public static boolean compare(int a,int b){
  System.out.println("int");
  return a==b;
}
public static boolean compare(byte a,byte b){
   System.out.println("byte");
   return a==b;
}
public static boolean compare(short a,short b){
   System.out.println("short");
   return a==b;
}
public static boolean compare(long a,long b){
   System.out.println("long");
   return a==b;
}
//需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。
public class demo{
public static void main(String[] args){
   int[] arr={1,2,3,4,5};
   
}
public void printArr(int[] arr){
System.out.println("[");
for(int i=0;i<arr.length;i++){
  if(i==arr.length-1){
      System.out.println(arr[i]+"]");
  }else{
       System.out.println(arr[i]+","); 
  }
}
}
}
//设计一个方法用于获取数组中元素的最大值
public static void main(String[] args){
    int[] arr={12, 45, 98, 73, 60};
    int num=getMax(arr);
    System.out.println("最大的数为:"+num); 
  }
}
public 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 void main(String[] args){
   int[] arr={1,2,3,4,5};
   int index=getIndex(arr,3);
   System.out.println(index);
}
public int getindex(int[] arr,int num){
  for(int i=0;i<arr.length;i++){
        if(arr[i]==num){
            return i;
        }
  }
  return -1;

}

综合练习

//机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
public class exercise1{
public static void main(String[] args){
   System.out.println("请输入机票价格：");
   Scanner sc=new Scanner(System.in);
   int ticket=sc.nextInt();
   System.out.println("请输入月份：");
   int month=sc.nextInt();
   int seat;
   while(true){
    System.out.println("请输入舱位：0 头等舱 1 经济舱");
   seat=sc.nextInt(); 
   if(seat==0 || seat==1){
      break;
  }
   }
   System.out.println("机票价格为："+getPrice(price,seat,month));
}
public double getPrice(int price,int seat,int month){
  if(month>=5 && month <=10){
       if(seat==0){
            price=price*0.9;
       }else{
            price=price*0.85;
       }
  }else if((month>=1&&month<=4)||month==11||month==12){
      if(seat==0){
            price=price*0.7;
       }else{
            price=price*0.65;
            
       }
  }else{
        price=price*1;
  }
 return price;
}
}

//判断 101 ~ 200 之间有多少个素数，并打印所有素数
public class exercise2{
   public static void main(String[] args){
    System.out.println("素数分别是:");
   int count=0;
  for(int i=101;i<=200;i++){
       boolean flag=true;
       for(int j=2;j<i/2;j++){
          if(i%j==0){
             flag=false;
             break;
          }
       }
       if(flag){
       System.out.print(i+" ");
          count++;
          System.out.println("一共有" + count + "个质数");
       }
  }
}

//验证码
//定义方法实现随机产生一个5位的验证码  验证码格式：长度为5 前四位是大写字母或者小写字母 最后一位是数字
public static void main(String[] args) {
        String[] brs=new String[5];
        brs=yanZhengMa();
        for (int i = 0; i < brs.length; i++) {
            System.out.print(brs[i]);
        }
    }
    public static String[] yanZhengMa(){
        char[] chs=new char[52];
        for (int i = 0; i < 51; i++) {
            if(i<=25){
                chs[i]=(char) ('A'+i);
            }else{
                chs[i]=(char) ('a'+i-26);
            }
        }
        Random r=new Random();

        String[] strs=new String[5];
        for (int i = 0; i < strs.length-1; i++) {
            int index=r.nextInt(52);
            strs[i]=chs[index]+"";
        }
        int num=r.nextInt(10);
        strs[strs.length-1]=""+num;
        return strs;
    }

//复制数组
public static void main(String[] args) {
       //把一个数组中的元素复制到另一个新数组中去。
        int[] nums= {1,2,3,4,5};
        int[] num=new int[nums.length];
        for (int i = 0; i < num.length; i++) {
            num[i]=nums[i];
        }
        for (int i = 0; i < num.length; i++) {
            System.out.print(num[i]);
        }

    }
//评委打分
//唱歌比赛中，有6名评委随机给选手打分，分数范围是[0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
public static void main(String[] args) {
         int[] grades=getScores();
        System.out.println("随机分数为:");
        for (int i = 0; i < grades.length; i++) {
            System.out.print(grades[i]+" ");
        }
         int sum=0;
        for (int i = 0; i < grades.length; i++) {
            sum+=grades[i];
        }
        double average=0.0;
        average=(sum-getMax(grades)-getMin(grades))/4;
        System.out.println();
        System.out.println("最小值为:"+getMin(grades));
        System.out.println("最大值为:"+getMax(grades));
        System.out.println("平均分为:"+average);
    }
    public static int[] getScores(){
        int[] scores=new int[6];
        Random r=new Random();
        for (int i = 0; i < scores.length; i++) {
            scores[i]=r.nextInt(101);
        }
        return scores;
    }
    public static int getMax(int[] grades){
        int max=grades[0];
        for (int i = 1; i < grades.length; i++) {
            if(grades[i]>max){
                max=grades[i];
            }
        }
        return max;
    }
    public static int getMin(int[] grades){
        int min=grades[0];
        for (int i = 1; i < grades.length; i++) {
            if(grades[i]<min){
                min=grades[i];
            }
        }
        return min;
    }

//某系统的数字密码（大于0），比如1983，采用加密方式进行传输。规则如下：先得到每位数，然后每位数都加上5 , 再对10求余，最后将所有数字反转，得到一串新数。
//第一种解法：
int[] nums={1,9,8,3};
        for (int i = 0; i < nums.length; i++) {
            nums[i]=(nums[i]+5)%10;
        }
        for (int i = nums.length-1; i >=0; i--)              {
            System.out.print(nums[i]);
        }
//第二种解法：
//把整数的每一个数字放到数组当中
  int[] nums={1,9,8,3};
  //将数组的数字进行运算
        for (int i = 0; i < nums.length; i++) {
            nums[i]=(nums[i]+5)%10;
        }
        //利用循环将数字反转
        for (int i = 0,j= nums.length-1; i < j; i++,j--) {
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
        }
        int number=0;
        //将数组的数转换为数字
        for (int i = 0; i < nums.length; i++) {
            number=number*10+nums[i];
        }
        System.out.println(number);
    }
//把整数上的每一位都添加到数组当中
 int number=12345;
    int temp=number;
    int count=0;
    while (number!=0){
        number=number/10;
        count++;
    }
        int[] arr=new int[count];
        int index=arr.length-1;
        while (temp !=0){
            int ge=temp%10;
            temp=temp/10;
            arr[index]=ge;
            index--;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
//数字解密 将8346变成1983
int[] arr={8,3,4,6};
//反转
for(int i=0,j=arr.length-1;i<j;i++,j--){
   int temp=arr[i];
   arr[i]=arr[j];
   arr[j]=temp;
}
//由于0~4减5得到负数且加密时是对10取余，则代表原数加密后是过10，则0~4之间需要加10
for(int i=0;i<arr.length;i++){
    if(arr[i]>=0&&arr[i]<=4){
         arr[i]=arr[i]+10;
    }
}
for(int i=0;i<arr.length;i++){
    arr[i]=arr[i]-5;
}
int number=0;
for(int i=0;i<arr.length;i++){
   number=number*10+arr[i];
}
System.out.println(number);

//一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。打印效果如下：（随机顺序，不一定是下面的顺序）
/* 需求：
        一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
        请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
        打印效果如下：（随机顺序，不一定是下面的顺序）
            888元的奖金被抽出
            588元的奖金被抽出
            10000元的奖金被抽出
            1000元的奖金被抽出
            2元的奖金被抽出
        */
        int[] arr={2, 588 , 888, 1000, 10000};
        Random r=new Random();
        for (int i = 0; i < arr.length; i++) {
            int index=r.nextInt(arr.length);
            int temp=arr[index];
            arr[index]=arr[i];
            arr[i]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

在这里插入图片描述

 //双色球
  public static void main(String[] args) {
     int[] crr = createNumber();
     for (int i = 0; i < crr.length; i++) {
         System.out.print(crr[i] + " ");
     }
     System.out.println();
     int[] input = userInput();
     for (int i = 0; i < input.length; i++) {
         System.out.print(input[i]+" ");
     }
     int redCount=0;
     int blueCount=0;
     for (int i = 0; i < input.length-1; i++) {
         if(input[i]==crr[i]){
             redCount++;
         }
     }
     if(input[input.length-1]==crr[crr.length-1]){
         blueCount++;
     }
     if(redCount == 6 && blueCount == 1){
         System.out.println("恭喜你，中奖1000万");
     }else if(redCount == 6 && blueCount == 0){
         System.out.println("恭喜你，中奖500万");
     }else if(redCount == 5 && blueCount == 1){
         System.out.println("恭喜你，中奖3000");
     }else if((redCount == 5 && blueCount == 0) ||  (redCount == 4 && blueCount == 1)){
         System.out.println("恭喜你，中奖200");
     }else if((redCount == 4 && blueCount == 0) ||  (redCount == 3 && blueCount == 1)){
         System.out.println("恭喜你，中奖10");
     }else if((redCount == 2 && blueCount == 1) ||  (redCount == 1 && blueCount == 1)|| (redCount == 0 && blueCount == 1)){
         System.out.println("恭喜你，中奖5");
     }else{
         System.out.println("谢谢参与，谢谢惠顾");
     }
 }

 public static int[] createNumber() {
     int[] arr = new int[7];
     Random r = new Random();
     for (int i = 0; i < arr.length - 1; ) {
         int num = r.nextInt(33) + 1;
         if (panduan(arr, num)) {
             arr[i] = num;
             i++;//代表只要满足条件，把数字封装进去才能往后走，如果不在这个位置
             //就表示panduan（）函数只对数字进行判断，如果不满足条件则直接用初始值0代替，这样数组中就会出现0的情况
         }
     }
     arr[arr.length - 1] = r.nextInt(16) + 1;
     return arr;
 }

 public static boolean panduan(int[] brr, int number) {
     for (int i = 0; i < brr.length - 1; i++) {
         if (number == brr[i]) {
             return false;
         }
     }
     return true;
 }

 public static int[] userInput() {
     Scanner sc = new Scanner(System.in);
     int[] arr = new int[7];
     Random r = new Random();
     for (int i = 0; i < arr.length - 1; ) {
         System.out.println("请输入第" + (i + 1) + "个红球号码:");
         int inputRed = sc.nextInt();
         if (inputRed >= 1 && inputRed <= 33) {
             if (panduan(arr, inputRed)) {
                 arr[i] = inputRed;
                 i++;
             } else {
                 System.out.println("当前号码已存在，请重新输入:");
             }
         } else {
             System.out.println("您当前输入号码不符合要求，请重新输入：");
         }

     }
     System.out.println("请输入蓝色球号码：");
     while (true) {
         int inputBlue = sc.nextInt();
         if (inputBlue >= 1 && inputBlue <= 16) {
             arr[arr.length - 1] = inputBlue;
             break;
         } else {
             System.out.println("您当前输入号码不符合规范，请重新输入：");
         }
     }
     return arr;
 }

类和对象

类

类是对象的数据类型，是具有相同属性和行为的一组对象的集合，是对现实生活中具有相同属性和行为的事物的抽象。
对象=属性+行为
属性指的是事物的特征，比如一个人的年龄、性别等特征，行为指的是事物能执行的操作，通常是指方法。
类和对象的关系：类是对事物的一种描述，对象则是具体存在的事物，对象是能够摸得着地真实存在的实体。类是对现实生活中一类具有共同属性和行为事物的抽象。

类的定义

publc class 类名{
  //成员变量
  变量1的数据类型  变量1；
  变量2的数据类型  变量2；
  ...
  //成员方法
  方法1；
  方法2；
}

对象的使用

创建对象的格式：
类名对象名=new 类名();
调用成员的格式：
对象名.成员变量；
对象名.成员方法();

//需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
public class Student{
//成员变量即属性
String name;
int age;
//成员方法
public void study(){
 System.out.println("好好学习，天天向上");
}
public void doHomework(){
System.out.println("键盘敲烂，月薪过万");
}
}
public class StudentDemo{
 public static void main(String[] args) {
 //创建对象
 Studnet s=new Student();
 //使用对象
 System.out.println(s.name+","+s.age);
 s.name="林青霞";
 s.age=30;
 System.out.println(s.name + "," + s.age);
 s.study();
 s.doHomework();
 }
}

对象的内存图

单个对象内存图

成员变量的使用过程
new出来的对象都是在堆内存的，方法都是在栈内存中存储的。
StudentTest01类中main()方法在栈内存中存储，栈内存中也存储了new出来对象在堆内存中的地址，在变量使用的时候直接根据栈内存中的地址指向堆内存的具体对象中属性的值并且使用。

成员方法调用过程
首先是一个类中的主方法(栈内存)，根据主方法中创建的对象去堆内存中调用对象中的具体属性和方法。调用完一个方法就自动销毁，栈内存是先进后出原则，则最先调用的主方法是最后销毁的，等待所有方法调用结束之后就销毁。

多个对象内存图

成员变量使用过程
成员方法调用过程
多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用一份

成员变量和局部变量

区别：

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

封装

面向对象三大特征之一（封装、继承、多态）
对象代表什么就得封装对应的数据并提供数据对应的行为
代码实现：将类的某些信息隐藏在类内部，不允许外部程序直接访问，通过该类提供的方法来实现对隐藏信息的操作和访问，成员变量使用private修饰，提供对应的getXxx()/setXxx()方法

private关键字

是一个修饰符，可以用来修饰成员（成员变量和成员方法）
被private修饰的成员只能在本类中访问，如果需要被其他类访问，需要提供对应的get变量名()方法，用于获取成员变量的值，方法用public修饰;提供set变量名(参数)方法用来设置成员变量的值，方法用public 修饰。

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

this关键字

主要用于指代成员变量，主要作用是区分局部变量和成员变量的重名问题，this指的是该类中的成员变量和方法而不是局部变量或者局部方法

public class Student {
    private String name;
    private int age;

    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);
    }
}

构造方法

创建对象时完成对对象数据的初识化
格式：
public class 类名{
修饰符类名(参数){
}
}
创建：若没有定义构造方法，系统会给出一个默认的无参构造方法，若定义了，系统则不会再提供默认构造方法
重载：自定义了带参构造方法，还要使用无参构造，必须重新写一个无参构造方法
可以使用带参构造，为成员变量进行初始化，无参数构造方法必须写上

/*
    学生类
 */
class Student {
    private String name;
    private int age;

    public Student() {}

    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);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

标准类制作

类名见名知意
成员变量使用private修饰
提供至少两个构造方法

无参构造
带全部参数的构造方法
get和set方法
提供给每个成员变量对应的setXxx()/getXxx()方法
添加其他行为方法

//定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
class Student{
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setAge(int age){
this.age=age;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void show(){
System.out.println(name + "," + age);
}
}
System.out.println(name + "," + age);

键盘录入涉及的方法

next()、nextLine()、nextInt()、nextDouble()
1、next()、nextLine()
可以接受任意数据，但是都会返回一个字符串，录入的所有数据都会看做字符串

Scanner sc=new Scanner(System.in);
String s=sc.next();
System.out.println(s);

Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
System.out.println(s);

2、nextInt()
只能接受整数，并且将录入的数据作为整数返回

Scanner sc = new Scanner(System.in);
int s = sc.nextInt();//只能录入整数
System.out.println(s);

3、nextDouble()
能接受整数和小数，但是都会作为小数返回

Scanner sc = new Scanner(System.in);
double d = sc.nextDouble();//录入的整数，小数都会看做小数。
						//录入字母会报错
System.out.println(d);

方法底层细节

next()、nextInt()、nextDouble()在接收数据的时候会遇到空格，回车，制表符其中的一个就会停止接收数据

Scanner sc = new Scanner(System.in);
double d = sc.nextDouble();
System.out.println(d);
//键盘录入：1.1 2.2//注意录入的时候1.1和2.2之间加空格隔开。
//此时控制台打印1.1
//表示nextDouble方法在接收数据的时候，遇到空格就停止了，后面的本次不接收。

Scanner sc = new Scanner(System.in);
double d = sc.nextDouble();
System.out.println(d);
//键盘录入：1.1 2.2//注意录入的时候1.1和2.2之间加空格隔开。
//此时控制台打印1.1
//表示nextDouble方法在接收数据的时候，遇到空格就停止了，后面的本次不接收。

Scanner sc = new Scanner(System.in);
String s = sc.next();
System.out.println(s);
//键盘录入：a b//注意录入的时候a和b之间加空格隔开。
//此时控制台打印a
//表示next方法在接收数据的时候，遇到空格就停止了，后面的本次不接收。

next()、nextInt()、nextDouble()在接收数据的时候会遇到空格制表符回车中的其中一个就会停止接收数据，但是这些符号加后面的数据还在内存中并没有接收，如果后面还有其他键盘录入的方法会自动将这些数据接收

Scanner sc = new Scanner(System.in);
String s1 = sc.next();
String s2 = sc.next();
System.out.println(s1);
System.out.println(s2);
//此时值键盘录入一次a b(注意a和b之间用空格隔开)
//那么第一个next();会接收a，a后面是空格，那么就停止，所以打印s1是a
//但是空格+b还在内存中。
//第二个next会去掉前面的空格，只接收b
//所以第二个s2打印出来是b

nextLine()方法是把一整行全部接收完毕

Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
System.out.println(s);
//键盘录入a b(注意a和b之间用空格隔开)
//那么nextLine不会过滤前面和后面的空格，会把这一整行数据全部接收完毕。

混用导致的问题

Scanner sc = new Scanner(System.in);//①
int i = sc.nextInt();//②
String s = sc.nextLine();//③
System.out.println(i);//④
System.out.println(s);//⑤

当代码运行到第二行的时候键盘录入123，但是实际上录入的是123+回车，而nextInt()是遇到空格、回车和制表符就会停止，所以nextInt()只能接收123，回车在内存中没有被接受，此时就被nextLine()接收了，所以一旦混用就会导致nextLine()接收不到任何数据。

使用方法

键盘录入分为两套：

next()、nextInt()、nextDouble()这三个配套使用,如果用了这三个中的其中一个，就不要使用nextLine()，会导致nextLine()接收不到任何数据
nextLine()单独使用，如果想要整数需要先接收再使用Integer.parseInt进行类型转换

Scanner sc = new Scanner(System.in);
String s = sc.next();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = sc.nextInt();//键盘录入123
System.out.println("此时为整数：" + i);

Scanner sc = new Scanner(System.in);
String s = sc.nextLine();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = Integer.parseInt(s);//想要整数再进行转换
System.out.println("此时为整数：" + i);

综合练习

需求:

格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来。

举例：

程序运行之后结果为：

姓名为:乔峰血量为:100

姓名为:鸠摩智血量为:100

乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。

鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。

乔峰举起拳头打了鸠摩智一下，造成了XX点伤害，鸠摩智还剩下XXX点血。

鸠摩智举起拳头打了鸠摩智一下，造成了XX点伤害，乔峰还剩下XXX点血。

乔峰K.O.了鸠摩智

public class Role{
private String name;
private int blood;
public Role(){
}
public Role(String name,int blood){
this.name=name;
this.blood=blood;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setBlood(int blood){
 this.blood=blood;
}
public int getBlood(){
return blood;
}
//调用方法攻击别人
public void attack(Role role){
  Random r=new Random();
  int hurt=r.nextInt(20)+1;
  int remainBlood=role.getBlood-hurt;
  role.setBlood(remainBlood);
  //this表示方法的调用者
  System.out.println(this.getName() + "举起拳头，打了" + role.getName() + "一下，" +
                "造成了" + hurt + "点伤害，" + role.getName() + "还剩下了" + remainBoold + "点血");
}
}

在上一个的基础上，我想看到人物的性别和长相，打斗的时候我想看到武功招式。

举例：

程序运行之后结果为：

姓名为:乔峰血量为:100 性别为:男长相为:气宇轩昂

姓名为:鸠摩智血量为:100 性别为:男长相为:气宇轩昂

乔峰使出了一招【背心钉】，转到对方的身后，一掌向鸠摩智背心的灵台穴拍去。给鸠摩智造成一处瘀伤。

鸠摩智使出了一招【游空探爪】，飞起身形自半空中变掌为抓锁向乔峰。结果乔峰退了半步，毫发无损。

。。。。

乔峰K.O.了鸠摩智

分析：

长相是提前定义好的，提前放在一个数组当中，程序运行之后，从数组中随机获取。

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。"};
//受伤描述
String[] injures_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);
}
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 String getFace(){
      return face;
  }
}
}
public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
   public String getName() {
        return name;
    }

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

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }
 //定义一个方法用于攻击别人
    //思考：谁攻击谁？
    //Role r1 = new Role（）；
    //Role r2 = new Role（）；
    //r1.攻击(r2);
    //方法的调用者去攻击参数
    public void attack(Role role) {
        Random r = new Random();
        int index = r.nextInt(attacks_desc.length);
        String KungFu = attacks_desc[index];

        //输出一个攻击的效果
        System.out.printf(KungFu, this.getName(), role.getName());
        System.out.println();

        //计算造成的伤害 1 ~ 20
        int hurt = r.nextInt(20) + 1;

        //剩余血量
        int remainBoold = role.getBlood() - hurt;
        //对剩余血量做一个验证，如果为负数了，就修改为0
        remainBoold = remainBoold < 0 ? 0 : remainBoold;
        //修改一下挨揍的人的血量
        role.setBlood(remainBoold);

        //受伤的描述
        //血量> 90 0索引的描述
        //80 ~  90  1索引的描述
        //70 ~  80  2索引的描述
        //60 ~  70  3索引的描述
        //40 ~  60  4索引的描述
        //20 ~  40  5索引的描述
        //10 ~  20  6索引的描述
        //小于10的   7索引的描述
        if (remainBoold > 90) {
            System.out.printf(injureds_desc[0], role.getName());
        }else if(remainBoold > 80 && remainBoold <= 90){
            System.out.printf(injureds_desc[1], role.getName());
        }else if(remainBoold > 70 && remainBoold <= 80){
            System.out.printf(injureds_desc[2], role.getName());
        }else if(remainBoold > 60 && remainBoold <= 70){
            System.out.printf(injureds_desc[3], role.getName());
        }else if(remainBoold > 40 && remainBoold <= 60){
            System.out.printf(injureds_desc[4], role.getName());
        }else if(remainBoold > 20 && remainBoold <= 40){
            System.out.printf(injureds_desc[5], role.getName());
        }else if(remainBoold > 10 && remainBoold <= 20){
            System.out.printf(injureds_desc[6], role.getName());
        }else{
            System.out.printf(injureds_desc[7], role.getName());
        }
        System.out.println();


    }


    public void showRoleInfo() {
        System.out.println("姓名为：" + getName());
        System.out.println("血量为：" + getBlood());
        System.out.println("性别为：" + getGender());
        System.out.println("长相为：" + getFace());
    }

}
public class GameTest {
    public static void main(String[] args) {
        //1.创建第一个角色
        Role r1 = new Role("乔峰",100,'男');
        //2.创建第二个角色
        Role r2 = new Role("鸠摩智",100,'男');

        //展示一下角色的信息
        r1.showRoleInfo();
        r2.showRoleInfo();

        //3.开始格斗 回合制游戏
        while(true){
            //r1开始攻击r2
            r1.attack(r2);
            //判断r2的剩余血量
            if(r2.getBlood() == 0){
                System.out.println(r1.getName() + " K.O了" + r2.getName());
                break;
            }

            //r2开始攻击r1
            r2.attack(r1);
            if(r1.getBlood() == 0){
                System.out.println(r2.getName() + " K.O了" + r1.getName());
                break;
            }
        }
    }
}

输出语句跟以前有所不同，用的是System.out.printf();该输出语句支持%s的占位符

public class Test {
    public static void main(String[] args) {
    //两部分参数：
        //第一部分参数：要输出的内容%s（占位）
        //第二部分参数：填充的数据
        
        System.out.printf("你好啊%s","张三");//用张三填充第一个%s
        System.out.println();//换行
        System.out.printf("%s你好啊%s","张三","李四");//用张三填充第一个%s，李四填充第二个%s

}
  }

需求：

定义数组存储3个商品对象。

商品的属性：商品的id，名字，价格，库存。

创建三个商品对象，并把商品对象存入到数组当中。

public class Goods{
private String id;
private String name;
private double price;
private int count;
}
 public Goods() {
    }

    public Goods(String id, String name, double price, int count) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.count = count;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }
public class GoodsTest{
public static void main(String[] args){
 Goods[] arr=new Goods[3];
 Goods g1=new Goods("001","华为P40",5999.0,100);
 Goods g2=new Goods("002","保温杯",227.0,50);
 Goods g3=new Goods("003","枸杞",12.7,70);
 arr[0]=g1;
 arr[1]=g2;
 arr[2]=g3;
 for(int i=0;i<arr.length;i++){
      Goods goods=arr[i];
      System.out.println(goods.getId() + ", " + goods.getName() + ", " + goods.getPrice() + ", " + goods.getCount());
 }
}
}

需求：

定义数组存储3部汽车对象。

汽车的属性：品牌，价格，颜色。

创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组当中。

public class Car {
    private String brand;//品牌
    private int price;//价格
    private String color;//颜色


    public Car() {
    }

    public Car(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

import java.util.Scanner;

public class CarTest {
    public static void main(String[] args) {
        //1.创建一个数组用来存3个汽车对象
        Car[] arr = new Car[3];

        //2.创建汽车对象，数据来自于键盘录入
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            //创建汽车的对象
            Car c = new Car();
            //录入品牌
            System.out.println("请输入汽车的品牌");
            String brand = sc.next();
            c.setBrand(brand);
            //录入价格
            System.out.println("请输入汽车的价格");
            int price = sc.nextInt();
            c.setPrice(price);
            //录入颜色
            System.out.println("请输入汽车的颜色");
            String color = sc.next();
            c.setColor(color);

            //把汽车对象添加到数组当中
            arr[i] = c;
        }

        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            Car car = arr[i];
            System.out.println(car.getBrand() + ", " + car.getPrice() + ", " + car.getColor());
        }
    }
}

需求 :

定义数组存储3部手机对象。

手机的属性：品牌，价格，颜色。

要求，计算出三部手机的平均价格

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;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}
import java.math.BigDecimal;

public class PhoneTest {
    public static void main(String[] args) {
        //1.创建一个数组
        Phone[] arr = new Phone[3];

        //2.创建手机的对象
        Phone p1 = new Phone("小米",1999,"白色");
        Phone p2 = new Phone("华为",4999,"蓝色");
        Phone p3 = new Phone("魅族",3999,"红色");

        //3.把手机对象添加到数组当中
        arr[0] = p1;
        arr[1] = p2;
        arr[2] = p3;

        //4.获取三部手机的平均价格
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //i 索引  arr[i] 元素（手机对象）
            Phone phone = arr[i];
            sum = sum + phone.getPrice();
        }

        //5.求平均值
        //数据能不写死，尽量不写死
        //int avg = sum / arr.length;

        double avg2 = sum * 1.0 / arr.length;

        System.out.println(avg2);//3665.6666666666665
    }
}

定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。

学生的属性：学号，姓名，年龄。

要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。

要求2：添加完毕之后，遍历所有学生信息。

要求3：通过id删除学生信息

如果存在，则删除，如果不存在，则提示删除失败。

要求4：删除完毕之后，遍历所有学生信息。

要求5：查询数组id为“heima002”的学生，如果存在，则将他的年龄+1岁

package com.itheima.test8;

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;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public class Test{
public static void main(String[] args){
Student[] stu=new Student[3];
Student stu1=new Student(1,"zhangsan",23);
Student stu2=new Student(2, "lisi", 24);
stu[0]=stu1;
stu[1]=stu2;
//要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
Student stu4=new Student(1, "zhaoliu", 26);
//唯一性判断
boolean flag=contains(stu,stu4.getId());
if(flag){
   System.out.println("当前id重复，请修改id后再进行添加");
}else{
   int count=getCount(stu);
   if(count==stu.length){
      Student[] newArr=createNewArr(stu);
      newArr[count]=stu4;
      printArr(newArr);
   }
}

}
public static void printArr(Student[] arr){
  for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if(stu != null){
                System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
            }
        }
}
public static boolean contains(Student[] stus,int id){
for(int i=0;i<stus.length;i++){
   Student stu=stus[i];
   if(stu.id==id){
    return false;
   }
}
return true;
}
}
public static int getCount(Student[] arr){
 int count=0;
  for (int i = 0; i < arr.length; i++) {
            if(arr[i] !=null){
             count++;
            }
}
return count;
}
public static Student[] createNewArr(Student[] arr){
//创建一个新数组，长度=老数组长度+1
//后把老数组的元素拷贝到新数组中
   Student[] newArr=new Student[arr.length+1];
   //循环遍历得到老数组中的每一个元素
   for(int i=0;i<arr.length;i++){
   //将老数组元素添加到新数组中
     newArr[i]=arr[i];
   }
   //返回数组
   return newArr;
}

public class Test3 {
    public static void main(String[] args) {
        /*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
        学生的属性：学号，姓名，年龄。

        要求3：通过id删除学生信息
            如果存在，则删除，如果不存在，则提示删除失败。
        要求4：删除完毕之后，遍历所有学生信息。

       */


        //1.创建一个数组用来存储学生对象
        Student[] arr = new Student[3];
        //2.创建学生对象并添加到数组当中
        Student stu1 = new Student(1, "zhangsan", 23);
        Student stu2 = new Student(2, "lisi", 24);
        Student stu3 = new Student(3, "wangwu", 25);

        //3.把学生对象添加到数组当中
        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;

        /*要求3：通过id删除学生信息
        如果存在，则删除，如果不存在，则提示删除失败。*/

        //要找到id在数组中对应的索引
        int index = getIndex(arr, 2);
        if (index >= 0){
            //如果存在，则删除
            arr[index] = null;
            //遍历数组
            printArr(arr);
        }else{
            //如果不存在，则提示删除失败
            System.out.println("当前id不存在，删除失败");
        }





    }



    //1.我要干嘛？  找到id在数组中的索引
    //2.我需要什么？ 数组 id
    //3.调用处是否需要继续使用方法的结果？ 要
    public static int getIndex(Student[] arr , int id){
        for (int i = 0; i < arr.length; i++) {
            //依次得到每一个学生对象
            Student stu = arr[i];
            //对stu进行一个非空判断
            if(stu != null){
                int sid = stu.getId();
                if(sid == id){
                    return i;
                }
            }
        }

        //当循环结束之后，还没有找到就表示不存在
        return -1;
    }

    public static void printArr(Student[] arr){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if(stu != null){
                System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
            }
        }
    }


}

public class Test4 {
    public static void main(String[] args) {
        /*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
        学生的属性：学号，姓名，年龄。

        要求5：查询数组id为“2”的学生，如果存在，则将他的年龄+1岁*/


        //1.创建一个数组用来存储学生对象
        Student[] arr = new Student[3];
        //2.创建学生对象并添加到数组当中
        Student stu1 = new Student(1, "zhangsan", 23);
        Student stu2 = new Student(2, "lisi", 24);
        Student stu3 = new Student(3, "wangwu", 25);

        //3.把学生对象添加到数组当中
        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;


        //4.先要找到id为2的学生对于的索引
        int index = getIndex(arr, 2);

        //5.判断索引
        if(index >= 0){
            //存在， 则将他的年龄+1岁
            Student stu = arr[index];
            //把原来的年龄拿出来
            int newAge = stu.getAge() + 1;
            //把+1之后的年龄塞回去
            stu.setAge(newAge);
            //遍历数组
            printArr(arr);
        }else{
            //不存在，则直接提示
            System.out.println("当前id不存在，修改失败");
        }


    }

    //1.我要干嘛？  找到id在数组中的索引
    //2.我需要什么？ 数组 id
    //3.调用处是否需要继续使用方法的结果？ 要
    public static int getIndex(Student[] arr , int id){
        for (int i = 0; i < arr.length; i++) {
            //依次得到每一个学生对象
            Student stu = arr[i];
            //对stu进行一个非空判断
            if(stu != null){
                int sid = stu.getId();
                if(sid == id){
                    return i;
                }
            }
        }

        //当循环结束之后，还没有找到就表示不存在
        return -1;
    }

    public static void printArr(Student[] arr){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if(stu != null){
                System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
            }
        }
    }
}

API (Application Programming Interface 应用程序编程接口)

java中的API指的是JDK中提供各种功能的Java类，这些了将底层的实现细节封装了起来，不需要关心具体的实现类如何实现，只需要学习如何使用这些类即可

1.2如何使用API帮助文档

打开帮助文档
找到索引选项卡中的输入框

在这里插入图片描述

在输入框中输入Random
看类在哪个包下
看类的描述

在这里插入图片描述

看构造方法
看成员方法

String类

代表字符串，Java程序中国的所有字符串文字都被视为此类的实例，java程序中所有的双引号字符串都是String类的对象，String类在java.lang包下，使用的时候不需要导包

String类的特点

字符串不可变，它的值在创建之后不能被更改
虽然字符串的值是不可变的，但是他们可以被共享
字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[])
String类的构造方法
常用构造方法
public String() 创建一个空白字符串对象，不含有任何内容
public String(char[] chs) 根据字符数组的内容创建字符串对象
public String(byte[] bytes) 根据字节数组的内容创建字符串对象
String s=“abc”; 直接赋值的方法创建字符串对象，内容就是abc

public class StringDemo01 {
    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[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

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

创建字符串对象两种方式的区别

通过构造方法构建
通过new创建的字符串对象，每一次new 都会申请一个内存空间，虽然内容相同但是地址值不同
直接赋值方式创建
以""方式给出的字符串，只要字符串序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象并在字符串池中维护

字符串的比较

==
比较基本数据类型时比较的是具体的值
比较引用数据类型时比较的是对象地址值
equals方法的引用
方法介绍
public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写

public class StringDemo02 {
    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
    }
}