Java入门教程上

news2024/9/9 4:10:15

常见的cmd命令

类 class

字面量

数据类型

输入

   public static void main(String[] args) {
        Scanner a=new Scanner(System.in);
        int n=a.nextInt();
        int m=a.nextInt();
        System.out.println(m+n);
  }
}

算数运算符

package wclg;

public class test {
    public static void main(String[] args) {
        System.out.println("123"+123);
        System.out.println(1+99+"武昌理工");

    }
}

符合运算符隐藏了强制类型转换

逻辑运算符

短路运算符

&& ||  和& | 结果一样,只不过效率高

原反补



循环判断

Switch jdk12以上的特性

import java.util.Scanner;

public class day4 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        switch (n) {
            case 1 -> {
                System.out.println("一");
            }
            case 2 -> {
                System.out.println("二");
            }
            case 3 -> {
                System.out.println("三");

            }
            default -> {
                System.out.println("没有这种选项");
            }
        }
    }
}

获取随机数

猜数字小游戏

package tets;

import java.util.Random;
import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        Random rand = new Random();
        int n = rand.nextInt(100)+1;
        while(true){

            Scanner sc = new Scanner(System.in);
            int m=sc.nextInt();
            if(n==m){
                System.out.println("猜对了");
                break;
            }
            else if(m>n){
                System.out.println("猜大了");
            }
            else {
                System.out.println("猜小了");

            }
        }
    }
}

数组

流行的写法

数组的长度是 数组.length

数组名.fori

动态数组初始化

public class Test5 {
    public static void main(String[] args) {
        int [] arr =new int [5];
        for(int i=0;i<arr.length;i++){
            Scanner sc=new Scanner(System.in);
            arr[i]=sc.nextInt();
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
        }
    }
}

整型数组未初始化默认为0

打乱数组元素,随机交换元素

package wclg;

import java.util.Random;

public class class_61 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) { 
            int num = r.nextInt(arr.length);
            int tmp = arr[num];
            arr[num] = arr[i];
            arr[i] = tmp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
        }

    }
}



数组的内存分配

arr2 存的是arr1的地址,通过arr1的地址内容打印出相应的值

修改arr2的值,相当于通过arr2修改了所指的地址内容值

二维数组

方法

方法是程序中最小的执行单元

也就相当于c语言的函数

重载

重载顾名思义就是方法名相同,参数不同,编译器会根据参数不同调用相应的方法

import java.util.Scanner;

public class class_64 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int sum1=Add(a,b);
        System.out.println(sum1);
        int sum2=Add(a,b,c);
        System.out.println(sum2);

    }
    public static int Add(int a,int b){
        return a+b;
    }
    public static int Add(int a,int b,int c){
        return a+b+c;
    }
}

输出语句的认识

方法就是先进后出

引用

引用数据变量其实就是存的是地址值

import java.sql.SQLOutput;
import java.util.Scanner;
public class class_69 {
    public static void fun1(int []arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {

          System.out.printf("%d ",arr[i]);
            if(i<arr.length-1){
                System.out.print(",");
            }

        }
        System.out.println("]");
    }
    public static int fun2(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 fun3(int []arr,int n){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==n){
                return  1;
            }
        }
        return 0;
    }
    public static int[] fun4(int []arr,int from,int to){
        int []temp=new int[to-from];
        int j=0;
        for (int i = from; i < to; i++) {
            temp[j++]=arr[i];
        }
        return temp;

    }
    public static void main(String[] args) {
        int []arr={11,22,33,44,55};
        fun1(arr);
        int max=fun2(arr);
        System.out.println("max:="+max);
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int ret=fun3(arr,n);
        if(ret==1)
            System.out.println("存在");
        else
            System.out.println("不存在");
        int from=sc.nextInt();
        int to=sc.nextInt();
       int []copyArr= fun4(arr,from,to);
        for (int i = 0; i < copyArr.length; i++) {
            System.out.printf("%d ",copyArr[i]);
        }

    }

}

方法的值传递

传基本数据类型的方法.

public class Test1 {
    public static void main(String[] args) {
    int number=100;
        int ret=fun(number);
        System.out.println(ret);
    }
    public static int fun(int number) {
        number=200;
        return number;
    }
}

传引用数据类型

public class Test2 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5};
        fun(arr);
        System.out.println(arr[0]);
    }
    public static void fun(int []arr){
       arr[0]=100;
    }
}

练习

import javax.swing.*;
import java.util.Scanner;

public class class_74 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double score = sc.nextDouble();
        int month = sc.nextInt();
        String ret = sc.next();

        if (month >= 5 && month <= 10) {
            double m = fun(score, ret,0.9,0.85);
            System.out.println(m);
        } else if (month >= 11 && month <= 12 || month >= 1 && month <= 4) {
            double m = fun(score, ret,0.7,0.65);
            System.out.println(m);

        }
    }
        public static double fun ( double score, String ret,double a, double b) {
            if (ret.equals("头等舱"))
                score *= a;
            else
                score *= b;
            return score;
        }
    }

ctrl+p看函数参数

ctrl+alt+m自动抽取方法

public class Test2 {
    public static int is_prime(int i){
        for (int j = 2; j <=Math.sqrt(i) ; j++) {
            if(i % j == 0){
                return 0;
            }
        }
        return 1;
    }
    public static void main(String[] args) {
        int count = 0;
        for (int i = 101; i <=200; i++) {
            if(is_prime(i)==1)
            {
                count++;
                System.out.printf("%d ", i);
            }
        }
        System.out.println();
        System.out.println("total:="+count);
    }
}

import javax.swing.*;
import java.util.Random;
public class Test3 {
    public static void main(String[] args) {
        //1.大写字母和小写字母放入数组当中
        char []arr=new char[52];
        for (int i = 0; i < arr.length; i++) {
            if(i<=25) {
                //添加小写字母
                arr[i] = (char) (97 + i);
            }else{
                //-26之前i的值
                arr[i] = (char) (65 + i-26);
            }
        }
        //2.随机4次
        //随机抽取数组的索引
        //利用随机索引,获取对应的元素
        //然后4个字母拼接一起
        Random r=new Random();
        int j=0;
        String result="";
        for (int i = 0; i < 4; i++) {
            int index=r.nextInt(arr.length);
            result+=arr[index];
        }
        //3.随机抽取一个数字0-9
        Random c=new Random();
        int a=c.nextInt(10);
        //拼接数字
      result+=a;
      System.out.println(result);
    }
}

public class Test4 {
    public static void main(String[] args) {
        int []arr = {1,2,3,4,5,6,7,8,9};
        int []tmp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            tmp[i] = arr[i];
        }
        for (int i = 0; i < tmp.length; i++) {
            System.out.printf("%d ", tmp[i]);
        }
    }
}

shift+F6一键替换

import java.util.Scanner;
public class Test5 {
    public static void main(String[] args) {
     int []newArr=getScore();
     int max=getMax(newArr);
     int min=getMin(newArr);
     int sum=getSum(newArr);
       int df= (sum-max-min)/4;
       System.out.println(df);
    }
    public static int[] getScore() {
        int []arr=new int[6];
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<6;) {
           int score=sc.nextInt();
            if(score>=0 && score<=100) {
                arr[i]=score;
                i++;
            }
            else{
                System.out.println("输入成绩错误");
            }

        }
        return arr;
    }
    public static int getMax(int[] arr) {
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(max<arr[i]) {
                max=arr[i];
            }
        }
        return max;
    }
    public static int getMin(int[] arr) {
        int min=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(min>arr[i]) {
                min=arr[i];
            }
        }
        return min;
    }
    public static int getSum(int[] arr) {
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
}

import javax.swing.*;
import java.util.Scanner;
public class Test6 {
    public static void main(String[] args) {
        int n = 0;
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        int count = 0;
        int tmp=n;
        while (tmp != 0) {
            count++;
            tmp/=10;
        }
        int ret = fun(n,count);
        System.out.println(ret);
    }
    public static int fun(int n, int count){
        int []arr = new int[count];
        int i=arr.length-1;
        while(n!=0){
            arr[i--]=n%10;
            n/=10;
        }
        for ( int j = 0;j <count; j++) {
            arr[j]+=5;
            arr[j]%=10;
        }
        int left=0;
        int right=count-1;
       while(left<right){
           int tmp=arr[left];
           arr[left]=arr[right];
           arr[right]=tmp;
           left++;
           right--;
       }
       int number=0;
        for (int k = 0; k < count; k++) {
            number=number*10+arr[k];
        }
        return number;
    }
}

import java.util.Random;
public class Tets8 {
    public static void main(String[] args) {
   int[]arr={2,588,888,1000,10000};
   int[] newAarr=new int[arr.length];
   Random random=new Random();
   for(int i=0;i<5;){
       int index=random.nextInt(arr.length);
       int  ret=arr[index];
      if((fun(newAarr,ret))==0){
          newAarr[i++]=ret;

       }
   }
   for(int i=0;i<arr.length;i++){
       System.out.print(newAarr[i]+" ");
   }
    }
    public static int fun(int[] arr,int ret){
    for(int i=0;i<arr.length;i++){
        if(arr[i]==ret)
            return 1;
    }
    return 0;
    }
}

方法2

import java.util.Random;

public class Test9 {
    public static void main(String[] args) {
    int []arr= {2, 588, 888, 1000, 10000};
    int []newArr=new int[arr.length];
        Random myRandom=new Random();
        for(int i=0;i<arr.length;i++){
           int index=myRandom.nextInt(arr.length);
           int temp=arr[index];
           arr[index]=arr[i];
           arr[i]=temp;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

import java.util.Random;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        //1.生成中奖号码
        int[] arr = fun1();//123456 7
        //2.用户输入号码(红球+蓝球)
        int[] newarr = fun2();//654321 7 也算,只要存在即可
        //3.判断用户中奖情况
        int readcount=0;
        int bluecount=0;
        //判断红球
        for (int i = 0; i < newarr.length-1; i++) {
           int readnum= newarr[i];
            for (int j = 0; j < arr.length-1; j++) {
                if(readnum==arr[j]){
                    readcount++;
                    break;
                }
            }
        }
        //判断蓝球
        int bluednum= newarr[newarr.length-1];
        if(bluednum==arr[arr.length-1]){
            bluecount++;
        }


    }
    public static int[] fun2() {
        //用于用户购买的彩票号码
        int[] arr = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球号码");
            int readnum = sc.nextInt();
            //要求红球在1-33之间,并且不重复才添加数组里面
            if (readnum >= 1 && readnum <= 33) {
                int flag = contains(arr, readnum);
                if (flag == 0) {
                    arr[i] = readnum;
                    i++;
                } else {
                    System.out.println("重复,请重新输入 ");
                }
            } else {
                System.out.println("当前红球超出范围");
            }
        }
        System.out.println("输入蓝球号码");
        while (true) {
            int bluenum = sc.nextInt();
            if (bluenum >= 1 && bluenum <= 16) {
                arr[arr.length - 1] = bluenum;
                break;
            } else {
                System.out.println("蓝球号码超出范围请重新输入");
            }
        }
        return arr;
    }

    public static int[] fun1() {
        // 1.6个红球,一个蓝球
        //红球不能重复,蓝球可以重复
        int[] arr = new int[7];
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int readNum = r.nextInt(33) + 1;
            int flag = contains(arr, readNum);//保证红球不重复
            if (flag == 0) {
                arr[i] = readNum;
                i++;
            }
        }
        //获取蓝球号码
        //最后一个蓝球号码
        int bluenum = r.nextInt(16) + 1;
        arr[arr.length - 1] = bluenum;
        return arr;
    }

    public static int contains(int[] arr, int Num) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == Num) {
                return 1;
            }
        }
        return 0;
    }
}

面向对象

封装,继承,多态,面向对象的三大特性

面向对象就是找到对应的方法解决对应的问题

类和对象

不写main方法的类

默认初始化值

'

封装

比如人画圆, 画圆的方法属于圆的方法
对象代表什么,就得封装对应的数据,并提供数据对应的行为

private关键字

set修改成员变量的值

get是获取成员变量的值

import java.util.Set;

public class GirlFriend {
    private String name;
    private  int age;
    //针对于每一个私有化成员变量,都要有Get和set方法
    //set类方法:给成员变量赋值
    //get类方法:对外提供成员变量的值

    //作用:给成员变量name进行赋值
    public void  Set_name (String n){
       name = n;

    }
    //对外提供name属性的
    public String  Get_name (){
      return name;

    }
    //作用:给成员变量age进行赋值
    public void  Set_age (int a){
       if(a>=18 && a<=25){
           age=a;
       }else {
           System.out.println("非法参数");
       }

    }
    //对外提供age属性的
    public int  Get_age (){
        return age;

    }
    
    public void Sleep() {
        System.out.println("她在睡觉");
    }
    public void eat() {
        System.out.println("她在吃饭");
    }
}
public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend g = new GirlFriend();
         g.Set_name("小囧囧");
         g.Set_age(19);
         System.out.println(g.Get_name());
         System.out.println(g.Get_age());
        g.Sleep();
        g.eat();
    }
}

this 关键字

成员和局部变量

加this就使用成员变量的age 也就是 private 的age

public class Test2 {
    private  int age;
    public  void method(){
        int age=10;
        System.out.println(this.age);
    }
}
public class Tets1 {
    public static void main(String[] args) {
      Test2 t2=new Test2();
      t2.method();
    }
}

this的内存布局

this的本质是:        所在方法调用者的地址值

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend g = new GirlFriend();
         g.Set_name("小囧囧");
         g.Set_age(19);
         System.out.println(g.Get_name());
         System.out.println(g.Get_age());
        g.Sleep();
        g.eat();
    }
}
import java.util.Set;

public class GirlFriend {
    private String name;
    private  int age;
    //针对于每一个私有化成员变量,都要有Get和set方法
    //set类方法:给成员变量赋值
    //get类方法:对外提供成员变量的值

    //作用:给成员变量name进行赋值
    public void  Set_name (String name){
           this.name = name;

    }
    //对外提供name属性的
    public String  Get_name (){
      return name;

    }
    //作用:给成员变量age进行赋值
    public void  Set_age (int age){
       if(age>=18 && age<=25){
          this.age = age;
       }else {
           System.out.println("非法参数");
       }

    }
    //对外提供age属性的
    public int  Get_age (){
        return age;

    }

    public void Sleep() {
        System.out.println("她在睡觉");
    }
    public void eat() {
        System.out.println("她在吃饭");
    }
}

构造

创造对象的时候 ,虚拟机会自动调用构造方法,作用是给成员变量进行初始化

有参构造和空参构造

构造就是public加类名

public class Student {
    //如果我们自己没有任何的构造方法
    //那么虚拟机给我们加一个空参构造方法
    private String name;
    private int age;
    public Student(){
        System.out.println("看看我执行没有");
    }
    public  Student(String name, int age){
        this.name = name;
        this.age = 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 class StudentTest {
    public static void main(String[] args) {
        //创建对象
        //调用空参构造
       Student s = new Student("zhangsan",18);
     /*  s.setAge(18);
       s.setName("小囧囧");*/
       System.out.println(s.getAge());
        System.out.println(s.getName());
    }
}

如果我们需要键盘录入数据则使用空参构造最好

如果我们给数据使用有参构造最好
不同情况使用不同构造方法

标准javabean类型

下载插件ptg一键生成Javabean类型

这个也可以 点构造函数即可

package Test3;

public class User {
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;

    public User() {
    }

    public User(String username, String password, String email, String gender, int age) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }


    public String getUsername() {
        return username;
    }


    public void setUsername(String username) {
        this.username = username;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getEmail() {
        return email;
    }


    public void setEmail(String email) {
        this.email = email;
    }


    public String getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }


    public int getAge() {
        return age;
    }


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

    public String toString() {
        return "User{username = " + username + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";
    }
}

package Test3;

public class UserTest {
    public static void main(String[] args) {
        User u=new User("张三","123","666@qq.com","男",18);
        System.out.println(u);
    }
}

二个引用指向同一个对象

基本数据类型和引用数据类型

基本数据类型存的是真实值

引用数据类型存的是地址值

成员变量和局部变量区别

面向对象练习

练习1

第一版程序

在这段代码中,this.getName()和 role.getName()都是用来访问对象的方法。

  • this.getName()表示调用attack方法的对象(即攻击者)的名字。在Java中,关键字this代表当前对象的引用,所以this.getName()表示调用当前对象的getName()方法,获取当前对象的名字。

  • role.getName()表示被攻击的对象(即参数中的role)的名字。在Java中,role是attack方法的参数,它是一个Role类型的对象,在这个对象上调用getName()方法,获取被攻击对象的名字。

在这段代码中,Role不是数据类型,而是一个类名。在面向对象的编程中,类是用来描述具有相似属性和行为的对象的模板。在这里,Role类描述了角色的属性(如名字和血量)以及行为(如攻击)。在attack方法中,Role role表示传入的参数是一个Role类的实例,即被攻击的角色是一个Role类型的对象。

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


    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) {
        //计算造成的伤害1~20
        Random num = new Random();
        int hurt=num.nextInt(20)+1;
        //修改一下挨揍人的血量
       //剩余血量
        int remainboold=role.getBlood()-hurt;
        remainboold=remainboold<0?0:remainboold;
        //修改一下挨揍人的血量
        role.setBlood(remainboold);
        System.out.println(this.getName() +
                "举起拳头打了"+ role.getName()+"一下,造成了"+hurt+"点伤害"+
               "还剩下"+remainboold+"血量");
    }

    
}

        

public class GameTest {
    public static void main(String[] args) {
        // 1.创建第一个角色
        Role r1=new Role("乔峰",100);
        //2.创建第二个角色
        Role r2= new Role("鸠摩智",100);
        //3.开始格斗,回合制游戏
        while (true){
            //r1开始攻击r2
            r1.attack(r2);
            //判断r2的剩余血量
            if(r2.getBlood()==0){
                System.out.println(r1.getName()+"KO了"+r2.getName());
                break;
            }
            //r2攻击r1
            r1.attack(r2);
            if(r1.getBlood()==0){
                System.out.println(r2.getName()+"KO了"+r1.getName());
                break;
            }
        }

    }
}

优化版

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()+"KO了"+r2.getName());
                break;
            }
            //r2攻击r1
            r1.attack(r2);
            if(r1.getBlood()==0){
                System.out.println(r2.getName()+"KO了"+r1.getName());
                break;
            }
        }

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

    public Role(String name, int blood, char gender, String face, String[] boyfaces, String[] girlfaces) {
        this.name = name;
        this.blood = blood;
        this.gender = gender;
        this.face = face;
        this.boyfaces = boyfaces;
        this.girlfaces = girlfaces;
    }


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




        //计算造成的伤害1~20
        int hurt = r.nextInt(20) + 1;
        //修改一下挨揍人的血量
        //剩余血量
        int remainboold = role.getBlood() - hurt;
        remainboold = remainboold < 0 ? 0 : remainboold;
        //修改一下挨揍人的血量
        role.setBlood(remainboold);
       /*
        受伤的描述
        血量>90 0索引的描述
        80~90 1索引的描述
        70~80 2索引的描述
        60~70 3索引的描述
        40~60 4索引的描述
        20~50 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 <=50){
           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 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 == '男') {
            //从boyfaces里面随机
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];
        } else if (gender == '女') {
            //从girlfaces里面随机
            int index = r.nextInt(girlfaces.length);
            this.face = girlfaces[index];
        } else {
            this.face = "面目狰狞";
        }


    }


    public String[] getBoyfaces() {
        return boyfaces;
    }


    public void setBoyfaces(String[] boyfaces) {
        this.boyfaces = boyfaces;
    }


    public String[] getGirlfaces() {
        return girlfaces;
    }


    public void setGirlfaces(String[] girlfaces) {
        this.girlfaces = girlfaces;
    }

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

}

练习2

ctr+p查参数

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


}
package Tets;
public class GoodTest {
    public static void main(String[] args) {
        //1.创建一个数组
        Goods[]arr=new Goods[3];
        //2.创建3个商品对象
        Goods g1=new Goods("001","p40",5999.0,100);
        Goods g2=new Goods("002","p50",6999.0,200);
        Goods g3=new Goods("003","p60",7999.0,500);
        //3. 把商品添加到数组中
        arr[0]=g1;
        arr[1]=g2;
        arr[2]=g3;
        for (int i = 0; i < arr.length; i++) {
            Goods g=arr[i];
            System.out.println(g.getId()+","+g.getName()+","+g.getPrice()+","+g.getCount());
        }
    }
}

键盘录入

nextLine遇到空格不停止

练习3

string

package com.ithema;
import java.util.Random;
public class StringDemo01 {
    public static void main(String[] args) {
        //1.使用直接赋值的方式获取一个字符串对象
        String s1="abc";
        System.out.println(s1);
        //2.使用new的方式来获取一个字符串对象
        //空参构造:可以获取一个空白字符串对象
        String s2=new String();
        System.out.println('*'+s2+'!');
        //传递一个字符串,根据传递的字符串内容再创建一个新的字符串对象
        String s3=new String("abc");
        System.out.println(s3);
        //传递一个字符数组,根据字符数组的内容再创建一个新的字符串对象
        //需求:我们修改字符串的内容  abc Qbc
        char []arr={'a','b','c'};
        String s4=new String(arr);
        System.out.println(s4);
       //传递一个字节数组,根据字节数组的内容再创建一个新的字符串对象
        byte []bytes={97,98,99};
        String s5=new String(bytes);
        System.out.println(s5);

    }
}

引用数据类型 s1!=s2 因为new开辟不同的空间

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1809223.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

iOS调整collectionViewCell顺序

效果图 原理 就是设置collectionView调整顺序的代理方法&#xff0c;这里要注意一点 调整过代理方法之后&#xff0c;一定要修改数据源&#xff0c;否则导致错乱。 还有就是在collectionView上面添加一个长按手势&#xff0c;在长按手势的不同阶段&#xff0c;调用collectionV…

【数据结构】AVL树(平衡二叉树)

目录 一、AVL树的概念二、AVL树的节点三、AVL树的插入四、AVL树的旋转1.插入在较高左子树的左侧&#xff0c;使用右单旋2.插入在较高右子树的右侧&#xff0c;使用左单旋3.插入较高左子树的右侧&#xff0c;先左单旋再右单旋4.插入较高右子树的左侧&#xff0c;先右单旋再左单旋…

论文研读 A Comparison of TCP Automatic Tuning Techniques for Distributed Computing

论文《分布式计算中TCP自动调优技术的比较》由Eric Weigle和Wu-chun Feng撰写&#xff0c;探讨了自动调整TCP缓冲区大小以提升分布式应用性能的不同方法。文章首先讨论了手动优化TCP缓冲区大小的局限性&#xff0c;并介绍了研究人员提出的各种自动调优技术来应对这些挑战。 作者…

打造智慧工厂核心:ARMxy工业PC与Linux系统

智能制造正以前所未有的速度重塑全球工业格局&#xff0c;而位于这场革命核心的&#xff0c;正是那些能够精准响应复杂生产需求、高效驱动自动化流程的先进设备。钡铼技术ARMxy工业计算机&#xff0c;以其独特的设计哲学与卓越的技术性能&#xff0c;正成为众多现代化生产线背后…

2024全国大学生数学建模竞赛优秀参考资料分享

0、竞赛资料 优秀的资料必不可少&#xff0c;优秀论文是学习的关键&#xff0c;视频学习也非常重要&#xff0c;如有需要请点击下方名片获取。 一、赛事介绍 全国大学生数学建模竞赛(以下简称竞赛)是中国工业与应用数学学会主办的面向全国大学生的群众性科技活动&#xff0c;旨…

⌈ 传知代码 ⌋ 记忆大师

&#x1f49b;前情提要&#x1f49b; 本文是传知代码平台中的相关前沿知识与技术的分享~ 接下来我们即将进入一个全新的空间&#xff0c;对技术有一个全新的视角~ 本文所涉及所有资源均在传知代码平台可获取 以下的内容一定会让你对AI 赋能时代有一个颠覆性的认识哦&#x…

MySQL 函数与约束

MySQL 函数与约束 文章目录 MySQL 函数与约束1 函数1.1 字符串函数1.2 数值函数1.3 日期函数1.4 流程函数 2 约束2.1 概述2.2 约束演示2.3 外键约束2.4 删除/更新行为 1 函数 函数是指一段可以直接被另一程序调用的程序或代码。 1.1 字符串函数 MySQL中内置了很多字符串函数&…

Python学习打卡:day02

day2 笔记来源于&#xff1a;黑马程序员python教程&#xff0c;8天python从入门到精通&#xff0c;学python看这套就够了 8、字符串的三种定义方式 字符串在Python中有多种定义形式 单引号定义法&#xff1a; name 黑马程序员双引号定义法&#xff1a; name "黑马程序…

攻防演练之-网络集结号

每一次的网络安全攻防演练都是各个安全厂商期待的网络安全盛会&#xff0c;因为目前的安全生态导致了只有在网络安全攻防演练期间&#xff0c;网络安全的价值才会走向台前&#xff0c;收到相关方的重视。虽然每一次都会由于各种原因不能如期举行&#xff0c;但是这一次的推迟总…

浏览器阻止屏幕息屏,js阻止浏览器息屏,Web网页阻止息屏

场景: 比如打开一个浏览器页面(比如大屏),想让它一直显示着,而不是过几分钟不操作就屏幕黑了.(电脑有设置电脑不操作就会多长时间就会息屏睡眠,如果要求每个客户都去操作一下电脑设置一下从不睡眠,这很不友好和现实.而且我也只想客户在大屏的时候才这样,其他页面就正常,按电脑设…

eNSP学习——RIP的路由引入

目录 主要命令 原理概述 实验目的 实验内容 实验拓扑 实验编址 实验步骤 1、基本配置 2、搭建公司B的RIP网络 3、优化公司B的 RIP网络 4、连接公司A与公司B的网络 需要eNSP各种配置命令的点击链接自取&#xff1a;华为&#xff45;NSP各种设备配置命令大全PDF版_ensp…

RAG检索与生成的融合

1、rag定义 检索增强生成 (RAG) 模型代表了检索系统和生成模型两大不同但互补组件完美结合的杰作。通过无缝整合相关信息检索和生成与背景相关的响应&#xff0c;RAG模型在人工智能领域达到了前所未有的复杂程度。 2、rag工作流程 2.1、rag整体框架 query通过llm处理后&…

【Golang】Go语言中defer与return的精妙交织:探索延迟执行与返回顺序的微妙关系

【Golang】Go语言中defer与return的精妙交织&#xff1a;探索延迟执行与返回顺序的微妙关系 大家好 我是寸铁&#x1f44a; 总结了一篇defer 和 return 返回值 的执行顺序探讨的文章✨ 喜欢的小伙伴可以点点关注 &#x1f49d; 前言 在Go语言中&#xff0c;defer 和return是两…

Codeforces Round 951 (Div. 2) 题解分享

A. Guess the Maximum 思路 贪心 毫无疑问的是&#xff0c;Alice会选择所有区间最大值的最小值-1&#xff0c;即。 关键是如何选取。我们注意到区间长度越大&#xff0c;这个区间的最大值是随着它不减的&#xff0c;所以如果Bob要让Alice选的最小的话&#xff0c;选择的区间…

1 c++多线程创建和传参

什么是进程&#xff1f; 系统资源分配的最小单位。 什么是线程&#xff1f; 操作系统调度的最小单位&#xff0c;即程序执行的最小单位。 为什么需要多线程&#xff1f; &#xff08;1&#xff09;加快程序执行速度和响应速度, 使得程序充分利用CPU资源。 &#xff08;2&…

FastAPI:在大模型中使用fastapi对外提供接口

通过本文你可以了解到&#xff1a; 如何安装fastapi&#xff0c;快速接入如何让大模型对外提供API接口 往期文章回顾&#xff1a; 1.大模型学习资料整理&#xff1a;大模型学习资料整理&#xff1a;如何从0到1学习大模型&#xff0c;搭建个人或企业RAG系统&#xff0c;如何评估…

Helm离线部署Rancher2.7.10

环境依赖&#xff1a; K8s集群、helm 工具 Rancher组件架构 Rancher Server 包括用于管理整个 Rancher 部署的所有软件组件。 下图展示了 Rancher 2.x 的上层架构。下图中&#xff0c;Rancher Server 管理两个下游 Kubernetes 集群 准备Rancher镜像推送到私有仓库 cat >…

RPA-UiBot6.0数据整理机器人—杂乱数据秒变报表

前言 友友们是否常常因为杂乱的数据而烦恼?数据分类、排序、筛选这些繁琐的任务是否占据了友友们的大部分时间?这篇博客将为友友们带来一个新的解决方案,让我们共同学习如何运用RPA数据整理机器人,实现杂乱数据的快速整理,为你的工作减负增效! 在这里,友友们将了…

SpringBoot3+Mybatis-Plus+h2数据库,入门Mybatis-Plus

SpringBoot3Mybatis-Plush2数据库&#xff0c;入门Mybatis-Plus mybatis-plus官网地址maven依赖数据库脚本配置文件实体类Mapper入门程序启动程序测试单元测试测试结果 Service层接口service层接口单元测试测试结果 项目结构 mybatis-plus官网地址 https://www.baomidou.com/ …

RocketMq源码解析六:消息存储

一、消息存储核心类 rocketmq消息存储的功能主要在store这个模块下。 核心类就是DefaultMessageStore。我们看下其属性 // 配置文件 private final MessageStoreConfig messageStoreConfig; // CommitLog 文件存储实现类 private final CommitLog commitLog; …