面向对象

面向对象基础案例及定义

1. 类和对象

类 (设计图纸)：是对象共同的特征
对象：真实存在的东西

新建对象 : 类名对象名 = new 类名( ) ;

用来描述一类事物的类叫：javabean（在javabean当中不写main方法）
编写main方法的类叫：测试类（可以在测试类中创建javabean）
一个文件定义一个class
方法：

   public void sleep(){                      // 方法
       System.out.println("睡觉");     
   }
   public void eat(){                        // 方法
       System.out.println("吃饭");

属性（成员变量）：

public class o1 {
    String name;                // 名字属性
    int age;                    // 年龄属性

局部变量：

package opp;

public class o2 {
    public void study(){ 
        int i=80;             // 局部变量（传递的是一个实际值）
    }

成员变量和局部变量区别：

2. 封装

set方法 ：给变量赋值
get方法 ：获取变量值

get和set的使用

package opp;

public class o1 {
    private String name;
    private int age;
   public void setName(String n){
       name = n;
   }
   public String getName(){
      return name;
   }
   public void setAge(int a){
       if(a>120 || a<0){
           System.out.println("数据不合理");
       }
       else{
           age = a;
       }
   }
   public int getAge(){
       return age;
   }
}

// 调用代码

package opp;

public class o {
    public static void main(String[] args) {
        o1 p1 = new o1();                                  // 在o1中创建了一个新的对象p2，p2具o1的全部属性和方法
        p1.setName("小明");                                 // 给p1的name属性赋值
        p1.setAge(18);
        System.out.println(p1.getName());                  // 输出数据
        System.out.println(p1.getAge());
    }
}

// 运行代码

this(只能调用本类下面的)——成员变量

package opp;

public class o1 {
    private String name;               // 本类
    private int age;
   public void setName(String n){
       this.name = n;                   // this调用本类

构造方法

package opp;

public class o2 {
    public o2(){                  // 空参构造
        
    }
    public o2(String n,int a){    //有参构造
      
    }
}

API : 别人已经编写好的代码，直接拿过来用（jdk帮助文档）

   Scanner     // 键盘录入
   Random      // 随机数

字符串类型

String                  // 在java.lang.String包下，对象在创建之后就不能改了
    
  1.直接赋值                             // String name="abcde"(常用，节约内存)—————堆里面地址
  2.new
    public String()                     // 创建空白字符
    public String(String original)      // 根据传入的字符串，创建字符串对象(不太常用)
    public String(char[] ches)          // 根据字符数组，创建字符串对象
    public String(byte[] ches)          // 根据字节数组，创建字符串对象
 
    
// 例如 ：    
package opp;

public class o3 {
    public static void main(String[] args) {
        String mokk=new String();                     // 串池里的地址
        System.out.println("@"+mokk+"!");
    }
}
 
@!
 
    
// 例如 ：    
package opp;

public class o3 {
    public static void main(String[] args) {    
       char[] b={'a','b','c','d'};
       String KL1=new String(b);
       System.out.println(b);
        
abcd 
  
    
    
// 例如 ：    
package opp;

public class o3 {
    public static void main(String[] args) {     
        byte[] a = {97, 98, 99, 100};
        String s = new String(a);
        System.out.println(s);

==号：

比基本数据类型的时候是比较数值
比引用数据类型的时候是比较地址值

**equals 和 equalsIgnoreCase(忽略大小写): **

package opp;

public class o3 {
    public static void main(String[] args) {
        String A="abc";
        String B="abd";
        boolean m=A.equals(B);                 // 利用equais进行比较
        System.out.println(m);
    }
}


false
    
    
package opp;

public class o3 {
    public static void main(String[] args) {
        String A="abc";
        String B="ABc";
        boolean m=A.equalsIgnoreCase(B);         // 利用equalsIgnoreCase进行比较         
        System.out.println(m);
    }
}


true
    
    
package opp;

public class o3 {
    public static void main(String[] args) {
        String A=new String("ABc");                // new 出来的
        String B="ABc";
        System.out.println(A==B);                  // 利用==进行比较
        
        
false 
    
    
  
    
package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);          // 系统录入方法的跟new出来方法相似
        System.out.println("请输入一个字符串");
        String A=s.next();
        String B="abc";
        System.out.println(A==B);                  // 利用==进行比较
    }
}

        
请输入一个字符串
abc
false

StringBuilder
        
StringJonier
        
StringBuffer
        
Pattern
        
Matcher

static—静态变量（经过实例化的）

静态变量随着类的出现而出现，优于对象
静态方法只能访问静态
非静态方法可以访问所有
静态方法中没有this关键字

public static String teachername;                    // 加上static可以多次调用老师信息

特点：被static修饰的成员，叫做静态变量
- 被该类所有对象共享
- 不属于对象属于类
- 随着类的加载而加载，优于对象的存在
  - 类名调用（推荐）例：s2.show();
  - 对象调用
特点：被static修饰的成员方法，叫做静态方法
- 多用在测试类和工具类中
- javabean类中很少使用
  - 类名调用（推荐）
  - 对象调用
工具类：（不是用来描述一类事物的，而是帮我们做一些事情的类）
- 类名见名之意 --- public calss ArrUtil {
- 私有化构造方法
- 方法定义为静态
javabean类：（描述一类事物的）
- 如student，teacher，cat .... , 要构造无参有参，get或set方法
测试类：
- 检查类是否书写正确，是程序的主路口

两测试类之间的调用

package opp;

public class static1 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4};
        String s = staic.printArr(arr);
        System.out.println(s);
        double[] arr1={5.1,9.6,7.6,8.2};
        double m = staic.getAverage(arr1);
        System.out.println(m);
    }
}

package opp;

import java.util.StringJoiner;

public class staic {
    public static void main(String[] args) {

    }

    public static String printArr(int[] arr) {
        StringBuilder sj=new StringBuilder();
        sj.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                sj.append(arr[i]);
            }else {
                sj.append(arr[i]).append(",");
            }
        }
        sj.append("]");
        return sj.toString();
    }
    public static double getAverage(double[] arr){
        double sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum=sum+arr[i];
        }
    return sum/ arr.length;
    }
}

利用工具类进行选取最大值

// 测试类

package opp;

import java.util.ArrayList;

public class tool {
    public static void main(String[] args) {
        ArrayList<tool1> list=new ArrayList<>();
        tool1 t1=new tool1("张三",23,"男");
        tool1 t2=new tool1("李四",60,"女");
        tool1 t3=new tool1("王五",18,"女");
        list.add(t1);
        list.add(t2);
        list.add(t3);
        int maxAgeStudent=STU.getMaxAgeStudent(list);
        System.out.println(maxAgeStudent);
    }
}

// 工具类

package opp;

import java.util.ArrayList;

public class STU {
    public static int getMaxAgeStudent(ArrayList<tool1> list){
        int max=list.get(0).getAge();
        for (int i = 1; i < list.size(); i++) {
            int num=list.get(i).getAge();
            if (max<num){
                max=num;
            }
        }
    return max;}
}

// javabean类

package opp;

public class tool1 {
    private String student;
    private int age;
    private  String gender;

    public tool1() {
    }

    public tool1(String student, int age, String gender) {
        this.student = student;
        this.age = age;
        this.gender = gender;
    }

    public String getStudent() {
        return student;
    }

    public void setStudent(String student) {
        this.student = student;
    }

    public int getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

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

3. 继承

extends

当类与类之间，存在共性的内容，并满足子类是父类的一种，可以考虑继承
只能单继承，可以多层继承
java的类都直接或间接的继承object 类
子类只能访问父类中非私有的成员
独立完成继承体系
- 构造方法不能被子类继承

方法的重写

方法名相同参数相同，调用的类不同（private<null<protected<public ）
当父类的方法不能满足子类现在需求时，需要进行方法重写
只有添加到虚方法中的方法才能被重写
子类重写父类方法时，返回值类型子类必须小于等于父类

书写格式

在继承体系中，子类出现了和父类中一模一样的方法声明，我么就称子类这个方法是重写的方法

@Override重写注释

校验子类重写时语法是否正确
如果出现了红色波浪线表示语法错误

继承+方法重新案例

package opp;

public class Test {                                       // 测试类
    public static void main(String[] args) {
        taidi ti=new taidi();                              // 创建taidi对象方便下面调用
        ti.eat();
        ti.home();
        ti.drink();
        HaShiqi ha=new HaShiqi();
        ha.drink();
        ha.eat();
        ha.home();
    }
}

package opp;

public class taidi extends dog {
    @Override                                               // 重写标识符
    public void eat() {
        super.eat();                                        // 调用父类方法 
        System.out.println("啃骨头");                        // 重写父类方法
    }
}

package opp;

public class HaShiqi extends dog {
    public void home(){
        System.out.println("哈士奇在拆家了");
    }
     @Override                                               // 重写标识符
    public void eat(){
        System.out.println("吃剩饭");                         // 重写父类方法
    }
}

package opp;

public class dog{                                             // 父类
    public void home(){
        System.out.println("狗看家");
    }
    public void eat(){
        System.out.println("狗吃狗粮");
    }
    public void drink(){
        System.out.println("狗在喝水");
    }
}

狗吃狗粮
啃骨头
狗看家
狗在喝水
狗在喝水
吃剩饭
哈士奇在拆家了

父类跟子类不能同时出现

4.多态

有继承才能有多态，要有方法重写，父类引用指向子类对象

多态调用的成员特点

变量调用：编译看左边，运行也看左边 a.name ;
方法调用：编译看左边，运行看右边 a.show( ) ;
弊端：不能使用子类的特有功能

包机制

使用同一个包中类时，不需要导包
使用java.lang包中类时，不需要导包
同时使用两个包中同名类的时候，需要用全名类 -- 包名+类名
其他情况都需要导包

包书写规则

公司域名反写+包的作用，需要全部英文小写，见名之意

强制转化+判断 instanceof

if (a instanceof dog){             // 判断a是否是dog类
            dog d=(dog)a;          // 将dog d强转为dog类
            d.lookhome();
        }


if (a instanceof dog d){             // 判断a是否是dog类，并进行强转
            d.lookhome();
        }

final

方法：该方法是最终方法，不能被重写
类：该类是最终类，不能被继承
变量：常亮，只能被赋值一次例：PI ，常量可以用 _ 表示

基本类型：数据值不变

引用类型：地址值不变，对象内部是可以改变的

代码块

先调用静态代码块 static{ } 数据初始化
在调用匿名代码块
最后调用局部代码块

抽象类

没有方法体的方法是抽象方法

为了不让外界创建它的对象

pubilc abstract class 类名

pulice abstract viod 方法名( ){

} 既要又要，提炼共性，创建特性

抽象类不能实例化（不能new对象）
抽象类中不一定有抽象对象，有抽象方法的类一定是抽象类
可以有构造方法
抽象类的子类（继承抽象类有哪些需要注意的）
- 要么重写抽象类中的所有抽象方法
- 要么是抽象类

接口

接口是一种规则，对行为的规范

接口的定义和使用 interface

public interface 接口名{

}

接口不能实例化
接口和类之间是实现关系，通过implements关键字表示

public class 类名 implement 接口名{

}

接口的子类
- 要么重写接口中的所有抽象方法
- 要么是抽象类

接口和类之间的关系

可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的继承关系

继承关系，可以单继承，也可以多继承

*接口和类可以单实现，也可以多实现

public class 类名 implement 接口名1 ，接口名2 { }

*实现类还可以在继承一个类的同时实现多个接口

public class 类名 extends 父类 implements 接口1，接口2{}

接口案例

package InterFace;

public class Test {
    public static void main(String[] args) {
        frog f=new frog("小青",1);
        System.out.println(f.getName()+","+f.getAge());

        f.eat();
        f.Swim();

        rabbit r=new rabbit("小白",2);
        System.out.println(r.getName()+","+r.getAge());

        r.eat();

        dog d=new dog("大黄",3);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.Swim();
    }
    
}

package InterFace;

public class dog extends Animal implements Swim{
    public dog() {

    }
    public dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("够吃骨头");
    }

    @Override
    public void Swim() {
        System.out.println("狗刨");
    }
}

package InterFace;

public class frog extends Animal implements Swim{
    public frog(){
    }
    public frog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }
    @Override
    public void Swim(){
        System.out.println("青蛙在蛙泳");
    }
}

package InterFace;

public class rabbit extends Animal{

    public rabbit(){

    }
    public rabbit(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
}

package InterFace;

public interface Swim {
    public abstract void Swim();
}

package InterFace;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    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 abstract void eat();
}

小青,1
青蛙吃虫子
青蛙在蛙泳
小白,2
兔子吃胡萝卜
大黄,3
够吃骨头
狗刨

允许在接口中定义默认方法，需要使用关键字default —— 解决接口升级问题

默认方法不是抽象方法所以不需要强制重写，如果重写了就不需要写default
格式：public default 返回值类型方法名（参数列表）
范例：public default void show（）
静态方法static不需要被重写

适配器设计模式

设计模式就是各种套路
适配器设计模式：解决接口与接口实现类之间的矛盾问题

内部类

b类是a类的一部分，且b类单独存在没有意义
内部类可以直接访问外部类的成员，包括私有，外部类不能直接访问内部类的成员

成员内部类（不用static修饰）

package other;

public class InterImpl {
    String carName;
    int carAge;
    String carColor;
    
    class Engine{
        String engineName;
        int engineAge;
        
        public void show(){
            System.out.println(carColor);                     // 调用内部类
            System.out.println(InterImpl.this.carAge);        // 调用外部类
        } 
    }
}


// 在外部调用内部类时：InterImpl.Engine IE = new InterImpl().new Engine();

静态内部类只能调用静态

内部类的分类

成员内部类：InterImpl.Engine IE = new InterImpl().new Engine();
静态内部类：InterImpl.Engine IE = new InterImpl().Engine();
局部内部类：
匿名内部类（重点掌握）：可以写在成员位置 ( javabean的属性位置 )，也可以写在局部位置

new Swim(){                          // 看Swim，如果Swim是接口就是实现关系，如果是类就是继承关系
    @Override
    public void swim(){
    sout("重写的方法")
    }
};

// 实现关系，方法重写，创建对象

当方法的参数是接口或者类时

以接口为例，可以传递这个接口的实现类对象

如果实现这个类只需要使用一次，就可以用匿名内部类简化代码

案例：文字版格斗*********

简单版

/*创建两个游戏人物，他们血量姓名都不同
谁最后没血了，就判定为血量多的ko了没血量的*/

package opp;

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

    // 调用javabean属性
    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;
    }


    public void attack(role rr) {
        Random r = new Random();
        int hurt = r.nextInt(20) + 1;
        int remainBlood = rr.getBlood() - hurt;
        remainBlood = remainBlood < 0 ? 0 : remainBlood;
        
        rr.setBlood(remainBlood);                                         // 更新被攻击角色的血量
        
        System.out.println(this.name + "攻击" + rr.getName()+"一下"+rr.getName()+"掉血"+hurt+"点，还剩"+remainBlood+"点血");
    }
}

package opp;

public class o1 {
    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(r1.getName()+"ko了"+r2.getName());
                break;
            }
            r2.attack(r1);
            if (r1.getBlood()==0){
                System.out.println(r2.getName()+"ko了"+r1.getName());
                break;
            }
        }
    }

}

大明攻击小强一下小强掉血7点，还剩93点血
小强攻击大明一下大明掉血7点，还剩93点血
大明攻击小强一下小强掉血7点，还剩86点血
小强攻击大明一下大明掉血19点，还剩74点血
大明攻击小强一下小强掉血4点，还剩82点血
小强攻击大明一下大明掉血12点，还剩62点血
大明攻击小强一下小强掉血15点，还剩67点血
小强攻击大明一下大明掉血9点，还剩53点血
大明攻击小强一下小强掉血13点，还剩54点血
小强攻击大明一下大明掉血1点，还剩52点血
大明攻击小强一下小强掉血5点，还剩49点血
小强攻击大明一下大明掉血19点，还剩33点血
大明攻击小强一下小强掉血13点，还剩36点血
小强攻击大明一下大明掉血13点，还剩20点血
大明攻击小强一下小强掉血1点，还剩35点血
小强攻击大明一下大明掉血19点，还剩1点血
大明攻击小强一下小强掉血7点，还剩28点血
小强攻击大明一下大明掉血14点，还剩0点血
小强ko了大明

souf的拓展

package opp;

public class o3 {
    public static void main(String[] args) {
        System.out.printf("%s你好啊%s","张三","李四");// 输出的语句用%s(占位)
        System.out.printf("%s你好啊%s","小王","小李");// 输出的语句用%s(占位)
    }
}

张三你好啊李四小王你好啊小李

**复杂版 : **

前序

package opp;

public class o1 {
    public static void main(String[] args) {

        role r1 = new role("大明", 100, '男');
        role r2 = new role("小强", 100, '女');

        r1.show();
        r2.show();
    }
}

package opp;

import java.util.Random;

public class role {
    private String name;
    private int blood;
    private char sex;
    private String face;

    String[] boyFaceArr = {"帅气逼人", "英姿飒爽", "风流倜傥", "一表人才"};
    String[] girlFaceArr = {"美轮美奂", "秀色可餐", "亭亭玉立", "亭亭玉立"};

    public role() {
    }

    public role(String name, int blood, char sex) {
        this.name = name;
        this.blood = blood;
        this.sex = sex;
        setFace(sex);                                     // 通过判断sex来定义face的输出
    }

       // 调用javabean属性
    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;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }

    public void setFace(char sex) {
        if (sex == '男') {
            Random r = new Random();
            int index = r.nextInt(boyFaceArr.length);
            this.face = boyFaceArr[index];
        } else if (sex == '女') {
            Random r = new Random();
            int index = r.nextInt(girlFaceArr.length);
            this.face = girlFaceArr[index];
        } else {
            this.face = "人妖";
        }
    }

    public String getFace() {
        return face;
    }

    public void show() {
        System.out.println("姓名：" + getName()+ "\n血量：" + getBlood() + "\n性别：" + getSex()+ "\n颜值：" + getFace());
    }
}

姓名：大明
血量：100
性别：男
颜值：一表人才
姓名：小强
血量：100
性别：女
颜值：秀色可餐

省级版:

package opp;

public class o1 {
    public static void main(String[] args) {

        role r1 = new role("大明", 100, '男');
        role r2 = new role("小强", 100, '女');

        r1.show();
        r2.show();

        while(true){
            r1.attack(r2);
            if (r2.getBlood()==0){
                System.out.println(r1.getName()+"ko了"+r2.getName());
                break;
            }
            r2.attack(r1);
            if (r1.getBlood()==0){
                System.out.println(r2.getName()+"ko了"+r1.getName());
                break;
            }
        }
    }
}

package opp;

import java.util.Random;

public class role {
    private String name;
    private int blood;
    private char sex;
    private String face;

    String[] boyFaceArr = {"帅气逼人", "英姿飒爽", "风流倜傥", "一表人才"};
    String[] girlFaceArr = {"美轮美奂", "秀色可餐", "亭亭玉立", "亭亭玉立"};

    String[] attacks_desc = {"%s使出了浑身解数，转到对方身后，一掌向%s背心拍去。",
            "%s使出了一招【背心钉】，转到对方身前，一掌向%s胸前拍去。",
            "%s大喝一声，身形急转，一招【游空探爪】向%s背心拍去。",};

    String[] be_attacks_desc = {"结果%s被[%s]一掌一扣，闷哼一声，血光喷向%s。",
            "结果%s被[%s]一掌一扣，闷哼一声，%s脸也被%s一抽。",
            "结果%s被[%s]一掌一扣，闷哼一声，%s脸被%s一抽，%s胸口也被",};

    public role() {
    }

    public role(String name, int blood, char sex) {
        this.name = name;
        this.blood = blood;
        this.sex = sex;
        setFace(sex);
    }

    // 调用javabean属性
    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;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }

    public void setFace(char sex) {
        if (sex == '男') {
            Random r = new Random();
            int index = r.nextInt(boyFaceArr.length);
            this.face = boyFaceArr[index];
        } else if (sex == '女') {
            Random r = new Random();
            int index = r.nextInt(girlFaceArr.length);
            this.face = girlFaceArr[index];
        } else {
            this.face = "人妖";
        }
    }

    public String getFace() {
        return face;
    }


    public void attack(role rr) {
        Random r = new Random();
        int attackIndex = r.nextInt(attacks_desc.length);
        String KongFu = attacks_desc[attackIndex];
        System.out.printf(KongFu, this.name, this.face, rr.getName());  // printf输出攻击描述,%s占位符将名字跟长相做定义
        int beAttackIndex = r.nextInt(be_attacks_desc.length);
        String beAttack = be_attacks_desc[beAttackIndex];               // 随机生成被攻击描述
        System.out.printf("\n", beAttack, this.name, rr.getName(), rr.getFace(), rr.getName(), rr.getFace(), rr.getName());
        int hurt = r.nextInt(20) + 1;
        int remainBlood = rr.getBlood() - hurt;                         // 计算剩余血量
        remainBlood = remainBlood < 0 ? 0 : remainBlood;                // 三元运算符判断剩余血量
        rr.setBlood(remainBlood);                                       // 更新被攻击角色的血量
        System.out.println(this.name + this.face + "攻击" + rr.getName() + "一下" + rr.getName() + "掉血" + hurt + "点，还剩" + remainBlood + "点血");
    }

    public void show() {
        System.out.println("姓名：" + getName()+ "\n血量：" + getBlood() + "\n性别：" + getSex()+ "\n颜值：" + getFace());
    }
}

姓名：大明
血量：100
性别：男
颜值：帅气逼人
姓名：小强
血量：100
性别：女
颜值：亭亭玉立
大明使出了一招【背心钉】，转到对方身前，一掌向帅气逼人胸前拍去。
大明帅气逼人攻击小强一下小强掉血9点，还剩91点血
小强大喝一声，身形急转，一招【游空探爪】向亭亭玉立背心拍去。
小强亭亭玉立攻击大明一下大明掉血2点，还剩98点血
大明使出了一招【背心钉】，转到对方身前，一掌向帅气逼人胸前拍去。
大明帅气逼人攻击小强一下小强掉血8点，还剩83点血
小强大喝一声，身形急转，一招【游空探爪】向亭亭玉立背心拍去。
小强亭亭玉立攻击大明一下大明掉血11点，还剩87点血
大明使出了一招【背心钉】，转到对方身前，一掌向帅气逼人胸前拍去。
大明帅气逼人攻击小强一下小强掉血8点，还剩75点血
小强使出了一招【背心钉】，转到对方身前，一掌向亭亭玉立胸前拍去。
小强亭亭玉立攻击大明一下大明掉血15点，还剩72点血
大明大喝一声，身形急转，一招【游空探爪】向帅气逼人背心拍去。
大明帅气逼人攻击小强一下小强掉血17点，还剩58点血
小强大喝一声，身形急转，一招【游空探爪】向亭亭玉立背心拍去。
小强亭亭玉立攻击大明一下大明掉血15点，还剩57点血
大明大喝一声，身形急转，一招【游空探爪】向帅气逼人背心拍去。
大明帅气逼人攻击小强一下小强掉血20点，还剩38点血
小强使出了浑身解数，转到对方身后，一掌向亭亭玉立背心拍去。
小强亭亭玉立攻击大明一下大明掉血17点，还剩40点血
大明大喝一声，身形急转，一招【游空探爪】向帅气逼人背心拍去。
大明帅气逼人攻击小强一下小强掉血13点，还剩25点血
小强使出了浑身解数，转到对方身后，一掌向亭亭玉立背心拍去。
小强亭亭玉立攻击大明一下大明掉血13点，还剩27点血
大明使出了浑身解数，转到对方身后，一掌向帅气逼人背心拍去。
大明帅气逼人攻击小强一下小强掉血10点，还剩15点血
小强使出了一招【背心钉】，转到对方身前，一掌向亭亭玉立胸前拍去。
小强亭亭玉立攻击大明一下大明掉血15点，还剩12点血
大明大喝一声，身形急转，一招【游空探爪】向帅气逼人背心拍去。
大明帅气逼人攻击小强一下小强掉血20点，还剩0点血
大明ko了小强

案例：对象数组练习

javaBean界面 :

package opp;

public class javaBean {
    private String brand;
    private int price;
    private String color;

    public javaBean(){

    }
    public javaBean(String brand,int price,String 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;
    }
}

运行界面：

package opp;

import java.util.Scanner;

public class o1 {
    public static void main(String[] args) {
        javaBean[] arr=new javaBean[3];             // 创建一个javaBean类下得数组
        Scanner s=new Scanner(System.in);           // 系统录入值
        for (int i = 0; i < arr.length; i++) {
            javaBean ji=new javaBean();             // 对象放在for循环内部可输出多次值，放在for循环外部只能输出一次值
            System.out.println("输入手机品牌");
            String brand=s.next();
            ji.setBrand(brand);
            System.out.println("输入价格");
            int price=s.nextInt();
            ji.setPrice(price);
            System.out.println("输入颜色");
            String color=s.next();
            ji.setColor(color);
            arr[i]=ji;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println("手机型号："+arr[i].getBrand()+",手机价格："+arr[i].getPrice()+",手机颜色："+arr[i].getColor());
        }
        int sum=0;
        for (int j = 0; j < arr.length; j++) {
            int lp=arr[j].getPrice();
            sum+=lp;
        }
        System.out.println(sum);
    }
}

输出界面：

输入手机品牌
小米
输入价格
2000
输入颜色
白
输入手机品牌
华为
输入价格
5000
输入颜色
黑
输入手机品牌
OPPO
输入价格
3000
输入颜色
蓝
手机型号：小米,手机价格：2000,手机颜色：白
手机型号：华为,手机价格：5000,手机颜色：黑
手机型号：OPPO,手机价格：3000,手机颜色：蓝
10000

黑马课程（94节，95节）***

因为没有-1索引，在用return的时候想结束该循环可以用return -1；进行结束

案例：用户登录

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        String name="张三";
        int code=123456;
        for (int i = 0; i < 3; i++) {                       // 超过三次输入失败就会自动终止
            System.out.println("请输入密码");
            int password=s.nextInt();
            System.out.println("请输入姓名");
            String inputName=s.next();
            if (password==code && inputName.equals(name)){   // 在进行字符串比较的时候只能用equals进行，不能用==号
                System.out.println("登录成功");
                break;
            }else if (password==code){
                System.out.println("姓名错误");
            }
            else {
                System.out.println("密码错误");
            }
        }
    s.close();}
}



请输入密码
123456
请输入姓名
张三
登录成功

案例：遍历字符串和统计

引言(charAt输出单个字符)

public char charAt(int indext);       // 根据索引返回字符串

int c = 数组名.charAt(索引)

    
public int length();                  // 返回此字符串长度

数组长度 ：   数组名.lenth
    
字符串长度 ： 字符串对象.length()

统计字符串长度代码

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("输入一趟字符串");
        String m= s.next();
        System.out.println(m.length());
    s.close();}
}


输入一趟字符串
ksiihdskjdkkdj
14

charAt的使用

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("输入一趟字符串");
        String m= s.next();
    s.close();
        for (int i = 0; i < m.length(); i++) {
            char k=m.charAt(i);                     // 根据索引返回字符串
            System.out.println(k);
        }
    }
}



输入一趟字符串
abc
a
b
c

统计不同字符个数 :

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("输入一趟字符串");
        String m= s.next();

        int bigCount=0;
        int smallCount=0;
        int count=0;
        for (int i = 0; i < m.length(); i++) {
            char k=m.charAt(i);                        // 按照索引打印字符串
            if (k>='a' && k<='z'){
                smallCount++;
            }
            else if (k>='A' && k<='Z') {
                bigCount++;
            }
            else {                                        // 如果统计数字字符  k>='0' && k<='9'
                count++;
            }

            }
        System.out.println(smallCount);
        System.out.println(bigCount);
        System.out.println(count);
        s.close();}
}




输入一趟字符串
ASDacd1234
3
3
4

拼接字符 :

package opp;

public class o3 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4};
        String input = spelling(arr);
        System.out.println(input);
    }
    
    public static String spelling(int[] arr){                // 定义
        if (arr==null){
            return "输入为空";
        }
        if (arr.length==0){
            return "[]";
        }
        String result="[";
        for (int i = 0; i < arr.length; i++) {
            if (i== arr.length-1){
                result=result + arr[i];
            }else {
                result = result + arr[i] + ",";
            }
        }
    return result+"]";                                     // 在控制台输出
    }
}



[1,2,3,4]

案例：金额转换*********

/* 定义大写数字，Scanner，判断Scanner
   将字符串转换成单个字符并输出
   输出时不足7位的前面补零
   加单位                        */


package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] bigCapital = {"零", "壹", "贰", "弎", "肆", "伍", "陆", "柒", "捌", "玖"};
        int num=0;
        while (true) {
            System.out.println("请输入一个数字");
            num = s.nextInt();
            if (num >= 0 && num <= 99999999) {                  // 限定输入数字的长度为7位，并且为正数
                break;
            } else {
                System.out.println("输入错误，请重新输入");
            }

        }
        
        String str = "";
        while (true) {
            int ge = num % 10;
            String big = bigCapital[ge];
            str=big+str;                                         // 把 “” 放到字符后面默认是倒序输出
            num=num/10;
            if (num==0){
                break;
            }
        }
        
        int count=7-str.length();
        for (int i = 0; i < count; i++) {
            str="零"+str;
        }
        
        String str1="";
        String[] arr={"佰","拾","万","仟","佰","拾","元"};
        for (int i = 0; i < arr.length; i++) {
            char ar=str.charAt(i);                                // 前后字符要统一
            str1=str1+ar+arr[i];                                  // 把 “” 放到字符前面默认是正序输出
        }
        System.out.println(str1);
        s.close();
    }
}



请输入一个数字
1234
零佰零拾零万壹仟贰佰弎拾肆元

案例：字符转换

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String num;                                       
        while (true) {
            System.out.println("请输入一个整数"); 
            num = s.next();
            boolean flag=check(num);                                       // 调用boolean，判断必须放在while内部
            if (flag){
                break;
            }
            else {
                System.out.println("输入错误");
                continue;
            }
        }
        for (int i = 0; i < num.length(); i++) {                            // 调用num
            char c=num.charAt(i);
            int po=c-49;
            String py=bigspell(po);
            System.out.print(py+" ");
        }
    }

    public static String bigspell(int num){                                  // 转换
    String[] a = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
    return a[num];
    }
    public static boolean check(String num) {                                 // 判断
        if (num.length() > 9) {
            return false;
        }
        for (int i = 0; i < num.length(); i++) {
            char check = num.charAt(i);
            if (check <= '0' || check >= '9') {
                return false;
            }
        }
        return true;
    }
}



请输入一个整数
1234
I II III IV

案例：号码屏蔽

引言(substring截取)

String substring(int beginIndex(从哪开始截),int endIndex(截到哪里))

String beyongNum=number.substring(0, 3);    
    
// 截取 (包头不包尾，包左不包右)--只影响输出结果，不影响原本数值
    

String substring(int beginIndex)
    
    
    
// 截取到末尾

substring的使用(手机号码的加密)

package opp;

public class o4 {
    public static void main(String[] args) {
        String number = "15689755631";
        String beyongNum=number.substring(0, 3);             // 利用substring截取头部
        String beyongNum1=number.substring(7);               // 利用substring截取尾部
        System.out.println(beyongNum+"****"+beyongNum1);     // 输出加密部分和漏出部分
    }
}



156****5631

身份证信息查看

package opp;

public class o4 {
    public static void main(String[] args) {
        String number = "371526200307296048";
        String beyongNum=number.substring(6, 10);
        String beyongNum1=number.substring(10,12);
        String beyongNum3=number.substring(12,14);
        char Num=number.charAt(16);
        
        // 截身份证倒数第二位,这里不能用substring，因为substring只能截字符串，而charAt可以截取字符并将其转换成int类型
        
        System.out.println("出生年月日；");
        System.out.print(beyongNum+"年");
        System.out.print(beyongNum1+"月");
        System.out.println(beyongNum3+"日");
        System.out.println("性别：");
        int num=Num-48;     
        
        // 获取ASCII码表中的字符char对应的数字0 ->48,所以要减去48
        
        if (num%2==0){
            System.out.println("女");
        }else {
            System.out.println("男");
        }
        System.out.println(num/2);
    }
}

// System.out.println("0"+0);     进行ASCII码表字符串对应数值的查询     0 —> 48

出生年月日；
2003年07月29日
性别：
女
2

引言replace替换

String result=talk.replace("TMD","***");           // 在变值之前不要忘记将字符串加引号

案例：敏感词替换

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("输入一段话");
        String talk=s.nextLine();
        String[] arr={"tmd","sb","cnmd"};
        for (int i = 0; i < arr.length; i++) {
            talk=talk.replace(arr[i],"***");
        }
        System.out.println(talk);
        s.close();
    }
}



输入一段话
sb tmd cnmd
*** *** ***

String是字符串常量，他们的值在创建之后不能更改

引言(StringBuilder)

可以看作一个容器，创建之后里面的内容是可变的
pubilc StringBuilder( )
public StringBuilder(String str)

public StringBuilder append(任意类型)        // 在末尾添加数据

    
pubilc StringBuilder reverse()              // 反转容器中的内容
    
    
pubilc int length()                          // 返回长度
    
    
public String toString()                     // 实现将StringBuilder转成String类型

应用StringBuilder

package opp;

public class o4 {
    public static void main(String[] args) {
        StringBuilder sb =new StringBuilder();
        System.out.println(sb);                  // 无参时打印的是属性值（为空）不是地址值
    }
}

reverse的应用

package opp;

public class o4 {
    public static void main(String[] args) {
        StringBuilder sb =new StringBuilder("abc");
        sb.append(0);                            // 在末尾进行添加
        sb.append(1.2);
        sb.append(true);
        System.out.println(sb);                  // 无参时打印的是属性值不是地址值
        sb.reverse();                            // 执行字符串反转
        System.out.println(sb);
    }
}



abc01.2true
eurt2.10cba

toString的应用

package opp;

public class o4 {
    public static void main(String[] args) {
        StringBuilder sb =new StringBuilder("abc");
        sb.append(0);
        sb.append(1.2);
        sb.append(true);
        
       // sb.append(0).append(1.2).append(true);    (链式编程)
        
        System.out.println(sb);              
        sb.toString();                           // 将StringBuilder变成String类型
        System.out.println(sb);
    }
}



abc01.2true
abc01.2true

链式编程示例

int a=getString().substring(1).replace("a","q").length();

sb.append(0).append(1.2).append(true);

对称字符串

字符反转（一般方法）

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("输入");
        String input=s.next();

        StringBuilder a=new StringBuilder();
        a.append(input);
        a.reverse();
        System.out.println(a);
        s.close();
    }
}


输入
123456
654321

字符反转（链式方法）

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("输入");
        String input=s.next();
        String r=new StringBuilder().append(input).reverse().toString();
        System.out.println(r);
        s.close();
    }
}



输入
123456
654321

比较两字符是否为对称字符串

package opp;

import java.util.Scanner;

public class o3 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("输入");
        String input=s.next();
        String r=new StringBuilder().append(input).reverse().toString();  
        
        // 链式方法调用StringBuilder方法进行反转，利用toString转化成string类型
        
        System.out.println(r);
        s.close();
        if (input.equals(r)){                                              // 利用equals进行比较
            System.out.println("对称字符串");
        }
        else {
            System.out.println("不是对称字符串");
        }
    }
}



输入
1221
1221
对称字符串

拼接字符串

package opp;

public class o4 {
    public static void main(String[] args) {
        int[] a={1,2,3};
        aroString(a);
    }
    public static void aroString(int[] a){               
        StringBuilder sb=new StringBuilder();           // 调用StringBuilder
        sb.append("[");                                 
        for (int i = 0; i < a.length; i++) {            // 遍历a数组进行输出
            if (i==a.length-1){
                sb.append(a[i]);
            }
            else{
                sb.append(a[i]).append(",");
            }
        }
        sb.append("]");
        System.out.println(sb);
    }
}



[1,2,3]

StringBuilder使用场景

字符串的拼接
字符串的翻转

Stringjoiner(没有空参构造)

可调用toString进行字符串转化
可高效方便的拼接字符串

StringJoiner sj=new StringJoiner("中间间隔符号"，"开始符号","结束符号") 
    
    
// 案例
package opp;

import java.util.StringJoiner;

public class o4 {
    public static void main(String[] args) {
        StringJoiner sj=new StringJoiner(",","[","]");       // 新建StringJoine对象
        sj.add("abc").add("bcd").add("hjk");                 // 给对象进行赋值
        System.out.println(sj);
        System.out.println(sj.length());                     // 计算所有字符的个数
    }
}



[abc,bcd,hjk]
13

扩展底层原理：字符串拼接

在拼接的时候，每拼接调一次就会多一个出来一个StringBuilder
没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池里的字符串
有变量参与每行拼接的代码都会在内存中创建新的字符串，浪费内存

扩展底层原理：StringBuilder

可以扩容
所有内容都会放到StringBuilder中，不会创建无用资源，会复用串池字符

案例：随机打乱字符

package opp;

import java.util.Random;

public class o4 {
    public static void main(String[] args) {
        String arr="abcde";
        char[] str = arr.toCharArray();
        Random r=new Random();
        for (int i = str.length - 1; i > 0; i--) {
            int index=r.nextInt(i);
            char temp=str[i];
            str[i]=str[index];
            str[index]=temp;
        }
        String str1=new String(str);
        System.out.println(str1);
    }
}



//  冒泡排序
edacb

案例：打乱验证码

package opp;

import java.util.Random;

public class o4 {
    public static void main(String[] args) {
        Random r = new Random();
        StringBuilder a = new StringBuilder();                  // 创建一个StringBuilder字符串方便拼接
        for (int i = 0; i < 4; i++) {
            if (i <= 1) {
                int num = r.nextInt(10);
                a.append(num);
            } else {
                int index = r.nextInt(26) + 65;
                char c = (char) index;
                a.append(c);
            }
        }
        String s = a.toString();
        System.out.println(s);                                   // 返回字符串
        char[] b = s.toCharArray();                              // 转换为字符数组
        check(b);
        System.out.println(b);
    }

    public static void check(char[] b) {                          // 调用随机数+冒泡排序定义方法
        Random r = new Random();
        for (int i = b.length-1 ; i >0; i--) {
            int index=r.nextInt(i);
            char lo=b[i];
            b[i]=b[index];
            b[index]=lo;
        }
    }
}



16CH
6H1C

案例：将数字字符转数字进行计算

package opp;

public class o4 {
    public static void main(String[] args) {
        String a = "100";
        String b = "20";
        int po = 0;
        for (int i = 0; i < a.length(); i++) {          
            char c = a.charAt(i);
            po = po*10+(c - 48);                        // 将字符转数字**
        }
        int p1 = 0;
        for (int i = 0; i < b.length(); i++) {         
            char c = b.charAt(i);
            p1 =p1*10+(c - 48);                         // 将字符转数字**
        }
        int allsum=hello(po,p1);
        System.out.println(allsum);
    }
    public static int hello(int po,int p1){
        int sum=po*p1;
    return sum;
    }
}



2000

案例：输出最后一个单词长度

split 方法将字符串分割成单词数组
    
// 字符串由若干单词组成，每个单词之间都有空格隔开，输出最后一个单词和它的单词长度，
 
    
package opp;

public class o4 {
    public static void main(String[] args) {
        String input = "Hello World Java Programming";
        
        String[] words = input.split(" ");             // 使用空格分割字符串为单词数组***
        
        
  // 拓展：String[] parts = str.split(regex, limit);    limit表示将字符分成几部分，regex表示间隔符

        
        String lastWord = words[words.length - 1];     // 获取最后一个单词
        int lastWordLength = lastWord.length();        // 获取最后一个单词的长度

        System.out.println("最后一个单词: " + lastWord);
        System.out.println("最后一个单词的长度: " + lastWordLength);
    }
}



最后一个单词: Programming
最后一个单词的长度: 11

集合

数组

可以存基本数据类型
可以存引用数据类型

集合

只能存引用数据类型
如果存基本类型只能转换成包装类

ArrayList<存储的数据类型（不要写基本数据类型）> ：泛型

ArrayList<String> list = new ArrayList<>();



package opp;

import java.util.ArrayList;

public class o4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
    }
}


[]

ArrayList成员方法

boolean add(E e)              // 添加元素，返回值表示：是否添加成功                增

boolean remove(E e)           // 删除指定元素，返回值表示：是否删除成功             删
    
E remove(int index)           // 删除指定索引元素，返回被删除元素
    
E set(index,E e)              // 修改指定索引下的元素，返回原来的元素               改
    
E get(int index)              // 获取指定索引元素                                查
  
int size()                    // 集合的长度，也就是集合中元素的个数

package opp;

import java.util.ArrayList;

public class o4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("bbb");
        list.add("ccc");
        list.add("bcd");
        list.remove("bbb");
        list.remove(0);
        list.set(0,"aaa");
        String b=list.get(1);
        System.out.println(b);
        for (int i = 0; i < list.size(); i++) {
            String str= list.get(i);
            System.out.println(str);
        }
    }
}


bcd
aaa
bcd

基本数据类型包装类

byte                    Byte
    
short                   Short
    
char                    Character
    
int                     Integer           .....

案例：调用ArrayList进行javabean遍历输出

package opp;

import java.util.ArrayList;

public class o4 {
    public static void main(String[] args) {
        ArrayList<o5> list = new ArrayList<>();
        o5 dm = new o5("大明", 29);                         // 直接调入javabean中，不需要在用set
        o5 xh = new o5("小红", 18);
        list.add(dm);                                      // 添加到arr集合中
        list.add(xh);
        for (int i = 0; i < 2; i++) {
            o5 sp = list.get(i);
            System.out.println("姓名: " + sp.getName() + ", 年龄: " + sp.getAge());
        }
    }
}



姓名: 大明, 年龄: 29
姓名: 小红, 年龄: 18

package opp;

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

public class o4 {
    public static void main(String[] args) {
        ArrayList<o5> list = new ArrayList<>();
        o5 sp1 = new o5();
        Scanner s = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = s.next();
        System.out.println("请输入年龄");
        int age = s.nextInt();
        sp1.setName(name);                    // 输入姓名调入javabean
        sp1.setAge(age);
        list.add(sp1);                        // 添加到arr集合中
        System.out.println(sp1.getName()+","+sp1.getAge());
    }

}



请输入姓名
hjk
请输入年龄
45
hjk,45

案例：判断id是否存在并返回参数

// javabean
package opp;

public class o5 {
    private String name;
    private String password;
    private String id;

    public o5() {
    }

    public o5(String name, String password, String id) {
        this.name = name;
        this.password = password;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

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

    public String getId() {
        return id;
    }

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



// 测试
package opp;

import java.util.ArrayList;

public class o4 {
    public static void main(String[] args) {
        ArrayList<o5> list=new ArrayList<>();
        o5 a=new o5("黑马","604829","241053010925");
        o5 b=new o5("白马","562314","241053010852");
        o5 c=new o5("红马","ws6233","241053010729");
        list.add(a);
        list.add(b);
        list.add(c);

        int index=contains(list,"241053010925");
        System.out.println(index);
    }

    public static int contains(ArrayList<o5> list,String id){
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getId().equals(id)){
                return i;
            }
        }
    return -1;
    }
}

案例：返回低于自定义价格的集合

// 测试

package opp;

import java.util.ArrayList;

public class o4 {
    public static void main(String[] args) {
        ArrayList<o5> list = new ArrayList<>();
        o5 m1 = new o5("华为", 10000);
        o5 m2 = new o5("小米", 2000);
        o5 m3 = new o5("锤子", 2999);

        list.add(m1);
        list.add(m2);
        list.add(m3);

        ArrayList<o5> countlist=getPrice(list,3000);          // 判断getPrice方法并将参数进行传递
        for (int i = 0; i < countlist.size(); i++) {
            o5 m4=countlist.get(i);
            System.out.println(m4.getBrand()+","+m4.getPrice());
        }
    }
    public static ArrayList<o5> getPrice(ArrayList<o5> list,int price){
        ArrayList<o5> newlist=new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getPrice()<price){                // 注意是调用集合里的price跟原输入price作对比***
                newlist.add(list.get(i));
            }
        }
    return newlist;}
}


// javaBean

package opp;

public class o5 {
    private String brand;
    private int price;

    public o5() {
    }

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

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


小米,2000
锤子,2999

案例：学生管理系统

当switch跟while同时存在的时候，switch跳出的是最内层的循环（只能跳出单层循环）

// 为让switch中的break生效必须在while前面加上一个自定义的限定词+：

loop:while (true) {                                // loop是限定词
    
switch (choose){
                        case "1":
                    System.out.println("添加学生");
                    break loop;                     // 在switch中参与限定词
   }
}



// 利用暂停虚拟机方法进行退出
 case "1":
                    System.out.println("退出");
                    System.exit(0);                  // 停止虚拟机运行

注意在while和for循环中，定义的类的遍历关系，如果定义在循环外部就遍历一次，再循环内部可以遍历多次

学生管理系统基础版

没有注册，密码修改，验证码这些选项
学生管理系统基础测试类

package opp;

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


// 测试类

public class o4 {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        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 s=new Scanner(System.in);
            String choose = s.next();
            switch (choose){
                case "1":
                    addStudnet(list);
                    break;
                case "2":
                    removeStudent(list);
                    break;
                case "3":
                    upsetStudent(list);
                    break;
                case "4":
                    upgetStudent(list);
                    break;
                case "5":
                    exit();
                    System.exit(0);
                default:
                    System.out.println("输入错误");
                }
            }
    }
    
   
// 添加学生方法    
    
    public static void addStudnet(ArrayList<Student> list) {
        Student student = new Student();
        Scanner s = new Scanner(System.in);
        while (true) {                                            // 学号唯一判断
            System.out.println("请输入学生学号：");
            String id = s.next();
            if (judageId(list, id)) {
                System.out.println("请重新输入");
                continue;
            } else {
                student.setId(id);
            break;}
        }                                                          // 学号唯一判断结束
            System.out.println("请输入学生姓名：");
            String name = s.next();
            student.setName(name);
            System.out.println("请输入学生年龄：");
            int age = s.nextInt();
            student.setAge(age);
            System.out.println("请输入学生居住地：");
            String address = s.next();
            student.setAddress(address);
            list.add(student);
            System.out.println("添加成功");
    } 
    
   
// 删除学生方法    
    
    public static void removeStudent(ArrayList<Student> list) {
        if(list.size()<=0){                                                // 集合长度为0时,返回无学生信息
            System.out.println("当前无学生信息");
            return;
        }
        Scanner s = new Scanner(System.in);
        while (true) {                                                     // Scanner的调用必须在循环内部
        System.out.println("请输入要删除的学生学号：");
        String id = s.next();
            for (int i = 0; i < list.size(); i++) {                        // 调用judageId方法进行学号唯一判断
                if (judageId(list, id)) {
                    list.remove(i);
                    System.out.println("删除学生" + id + "成功");
                    System.exit(0);                                  // 退出系统
                } else {
                    System.out.println("学号不存在，请重新输入");
                    continue;
                }
            }
        }
    }
    
    
// 修改学生方法    
    
    public static void upsetStudent(ArrayList<Student> list){
        if (list.size()<=0){
            System.out.println("当前无学生信息");
            return;
        }
        Scanner s = new Scanner(System.in);
        for (int i = 0; i < list.size(); i++) {
            System.out.println("请输入要修改的学生学号：");                // Scanner的调用必须在循环内部
            String id = s.next();
            if (judageId(list,id)){                                    // 调用judageId方法进行学号唯一判断
                System.out.println("请输入修改后的姓名：");
                String nowname = s.next();
                list.get(i).setName(nowname);                          // 调用set方法修改学生信息
                System.out.println("请输入修改后的年龄：");
                int nowage = s.nextInt();                         
                list.get(i).setAge(nowage);
                System.out.println("请输入修改后的居住地：");
                String nowaddress = s.next();
                list.get(i).setAddress(nowaddress);
                System.out.println("请输入修改后的学号：");
                String nowid = s.next();
                list.get(i).setId(nowid);
                System.out.println("修改成功");
            }
            else {
                System.out.println("修改学生不存在，请重新输入");
            continue;}
        }
    }
    
    
// 查找学生方法     
    
    public static void upgetStudent(ArrayList<Student> list){
        if (list.size()==0){
            System.out.println("当前无学生信息");
            return;
        }
        System.out.println("学号\t\t姓名\t\t年龄\t\t居住地");
        for (int i = 0; i < list.size(); i++) {
            Student s=list.get(i);
            System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"岁\t"+s.getAddress());
        }
    }
    
  
// 退出方法     
    
    public static void exit(){
        System.out.println("退出");
    }
    
    
// 判断学生方法     
    
    public static boolean judageId(ArrayList<Student> list,String id){
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getId().equals(id)){
                System.out.println("学号已存在");
            return true;}
        }
    return false;}
}

学生管理系统基础javaBean类

// javaBean方法


package opp;

public class Student {
    private String name;
    private int age;
    private String address;
    private String id;
    public Student() {

    }

    public Student(String name, int age, String address, String id) {
        this.name = name;
        this.age = age;
        this.address = address;
        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 String getAddress() {
        return address;
    }

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

    public String getId() {
        return id;
    }

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

学生管理系统基础版框架：

 public static void main(String[] args) {                               // 创建main方法
     
    }
    public static void addStudnet(ArrayList<Student> list) {            // 创建增方法                                             

    }
    public static void removeStudent(ArrayList<Student> list) {         // 创建删方法
       
    }
    public static void upsetStudent(ArrayList<Student> list){           // 创建改方法
        
    }
    public static void upgetStudent(ArrayList<Student> list){           // 创建查方法
        
    }
    public static void exit(){                                          // 创建退出方法
        
    }
    public static boolean judageId(ArrayList<Student> list,String id){  // 创建判断方法
        
    }

学生管理系统进阶版

/* 登录界面
   注册界面
   忘记密码
   验证码界面 */
   
package opp;

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

public class s1 {
    public static void main(String[] args) {
        ArrayList<Student5> list = new ArrayList<>();
        ArrayList<Student6> list1 = new ArrayList<>();
        while (true) {
            System.out.println("欢迎来到学生管理系统界面");
            System.out.println("请输入操作：1.登录 2.注册 3.忘记密码");

            Scanner s = new Scanner(System.in);

            String m = s.next();
            switch (m) {
                case "1":
                    String a = login(list, list1);
                    break;
                case "2":
                    regist(list, list1);
                    break;
                case "3":
                    forgetPassword(list1);
                    break;
                default:
                    System.out.println("输入错误");
            }
        }
    }

    public static void regist(ArrayList<Student5> list, ArrayList<Student6> list1) {
        Scanner userName = new Scanner(System.in);
        String newuserName;
        while (true) {
            System.out.println("请输入用户名：");
            newuserName = userName.next();
            boolean flag = checUsername(list, newuserName);
            if (flag) {
                boolean flag2 = judageId(list, newuserName);
                if (flag2) {
                    System.out.println("用户名已存在，请重新输入");
                    continue;
                } else {
                    System.out.println("用户名格式正确，请输入密码：");
                }
                break;
            } else {
                System.out.println("用户名格式错误，请输入密码：");
            }
        }                                               // 用户名格式

        String newPassword;
        while (true) {
            System.out.println("请输入要注册的密码：");
            newPassword = userName.next();
            System.out.println("请再次输入要注册的密码：");
            String newPassword1 = userName.next();

            if (newPassword.equals(newPassword1)) {
                System.out.println("注册成功");
                break;
            } else {
                System.out.println("两次密码不一致，请重新注册");
                continue;
            }
        }                                               // 密码格式

        String newPersonId;
        while (true) {
            System.out.println("请输入身份证号码：");
            newPersonId = userName.next();
            boolean flag3 = checId(list, newPersonId);
            if (flag3) {
                System.out.println("身份证格式正确");
                break;
            } else {
                System.out.println("身份证格式错误");
                continue;
            }
        }                                               // 身份证格式

        String phone;
        while (true) {
            System.out.println("请输入手机号：");
            phone = userName.next();
            boolean flag8 = newPhone(phone);
            if (flag8) {
                System.out.println("输入正确");
                break;
            } else {
                System.out.println("输入错误，请重新输入：");
            }
        }

        Student6 m = new Student6(newuserName, newPassword, newPersonId, phone);
        list1.add(m);
        System.out.println("注册成功");
        printList(list1);
    }                         // 注册界面

    public static String login(ArrayList<Student5> list, ArrayList<Student6> list1) {

        Scanner userName = new Scanner(System.in);
        String mi;
        String mima;
        // 用户名格式判断
        System.out.println("请输入用户名：");
        mi = userName.next();
        System.out.println("请输入密码：");

        mima = userName.next();
        boolean flag = inputUsername(list1, mi, mima);
        if (!flag) {
            System.out.println("未注册");
            return "";
        } else {
            System.out.println("输入正确：");
        }


        while (true) {                                              // 密码格式判断
            Random r = new Random();
            StringBuilder a = new StringBuilder();
            for (int i = 0; i < 4; i++) {
                if (i < 2) {
                    int ra = r.nextInt(10);
                    a.append(ra);
                }
                if (i < 4 && i >= 2) {
                    int ra = r.nextInt(26) + 65;
                    char rb = (char) ra;
                    a.append(rb);
                }
            }
            String b = a.toString();
            System.out.println("验证码" + b);
            System.out.println("输入手机验证码");


            StringBuilder newcode = new StringBuilder();
            String newCode = userName.next();
            newcode.append(newCode);
            String n = newcode.toString();
            boolean flage4 = phonejudage(newCode);                                    // 调用phone方法检查验证码格式是否正确
            if (flage4) {
                System.out.println("验证码格式正确");
            } else {
                System.out.println("验证码格式错误，请重新输入：");
            }
            if (b.equals(n)) {
                System.out.println("验证码正确");
                break;
            } else {
                System.out.println("验证码错误");
                continue;
            }
        }
        return "进入成功：";
    }

    private static boolean inputUsername(ArrayList<Student6> list1, String mi, String mima) {
        for (int i = 0; i < list1.size(); i++) {
            Student6 lo = list1.get(i);
            if (((mi.equals(lo.getNewuserName()) && (mima.equals(lo.getNewPassword()))))) {
                return true;
            }
        }
        return false;
    }

    public static void printList(ArrayList<Student6> list1) {
        for (int i = 0; i < list1.size(); i++) {
            Student6 student6 = list1.get(i);
            System.out.println(student6.getNewuserName() + "," + student6.getNewPassword() + "," + student6.getNewPersonId() + "," + student6.getPhone());
        }
    }

    private static boolean newPhone(String phone) {
        if (phone.length() != 11) {
            return false;
        }
        for (int i = 0; i < phone.length(); i++) {
            char newe = phone.charAt(i);                                   // 注意charAt的书写方法
            if (!(newe >= '0' && newe <= '9')) {
                return false;
            }
        }
        return true;
    }

    private static boolean phonejudage(String newCode) {
        if (newCode.length() != 4) {
            return false;
        }
        return true;
    }

    private static boolean checId(ArrayList<Student5> list, String newPersonId) {
        if (newPersonId.length() != 18) {
            return false;
        } else {
            char personId = newPersonId.charAt(0);                               // 判断身份证格式是否正确的方法

            if (personId == 0) {
                return false;
            }
            for (int i = 0; i < newPersonId.length() - 1; i++) {
                int a = newPersonId.charAt(i);
                if (!((a >= '0') && (a <= '9'))) {
                    return false;
                }
                char personId2 = newPersonId.charAt(17);
                if (!(personId2 == 'x' || ((personId2 >= '0') && (personId2 <= '9')) || (personId2 == 'X'))) {
                    return false;
                }

            }
        }
        return true;
    }

    private static boolean judageId(ArrayList<Student5> list, String newserName) {
        for (int i = 0; i < list.size(); i++) {
            Student5 student5 = list.get(i);
            String rightname = student5.getRegist();
            if (rightname.equals(newserName)) {
                return true;
            }
        }
        return false;
    }

    private static boolean checUsername(ArrayList<Student5> list, String newserName) {     // 判断长度的方法
        int len = newserName.length();
        if (len < 3 || len > 15) {
            return false;
        }
        for (int i = 0; i < newserName.length(); i++) {                                    // 判断输入格式的方法
            char ever = newserName.charAt(i);
            if (!((ever >= 'a' && ever <= 'z') || (ever >= 'A' && ever <= 'Z') || (ever >= '0' && ever <= '9'))) {
                return false;
            }
        }
        int count = 0;
        for (int j = 0; j < newserName.length(); j++) {
            char ever = newserName.charAt(j);
            if ((ever >= 'a' && ever <= 'z') || (ever >= 'A' && ever <= 'Z')) {
                count++;
                break;
            }
        }
        return count > 0;
    }

    public static void forgetPassword(ArrayList<Student6> list1) {
        System.out.println("输入用户名：");
        Scanner sc = new Scanner(System.in);
        String userName;
        userName = sc.next();
        for (int i = 0; i < list1.size(); i++) {
            Student6 inr = list1.get(i);
            if (!(userName.equals(inr.getNewuserName()))) {
                System.out.println("用户名不存在");
                break;
            }
            System.out.println("请输入身份证号码：");
            String peronId = sc.next();
            System.out.println("请输入手机号码：");
            String number = sc.next();
            boolean hio=findPassword(list1,peronId,number);
            if (!hio){
                System.out.println("输入有误：");
                return;
            }

            String de;
            String newde;
            while (true) {
                System.out.println("请输入新的密码：");
                de=sc.next();
                System.out.println("请再次输入新的密码：");
                newde=sc.next();
                if (de.equals(newde)){
                    System.out.println("两次密码输入一致");
                    break;
                }
                else {
                    System.out.println("两次密码不一致，需要重新输入");
                continue;
                }
            }
            inr.setNewPassword(de);
            System.out.println("密码修改成功");
        }
    }

    private static boolean findPassword(ArrayList<Student6> list1,String peronId, String number) {
        for (int i = 0; i < list1.size(); i++) {
            Student6 hii=list1.get(i);
            if (((peronId.equals(hii.getNewPersonId()))&&(number.equals(hii.getPhone())))){
                return true;
            }
        }
    return false;}
}

package opp;

public class Student6 {
    private String newuserName;
    private String newPassword;
    private String newPersonId;
    private String phone;

    public Student6() {
    }

    public Student6(String newuserName, String newPassword, String newPersonId, String phone) {
        this.newuserName = newuserName;
        this.newPassword = newPassword;
        this.newPersonId = newPersonId;
        this.phone = phone;
    }

    public String getNewuserName() {
        return newuserName;
    }

    public void setNewuserName(String newuserName) {
        this.newuserName = newuserName;
    }

    public String getNewPassword() {
        return newPassword;
    }

    public void setNewPassword(String newPassword) {
        this.newPassword = newPassword;
    }

    public String getNewPersonId() {
        return newPersonId;
    }

    public void setNewPersonId(String newPersonId) {
        this.newPersonId = newPersonId;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

package opp;

public class Student5 {
    private String in;
    private String regist;
    private String forgetCode;


    public Student5() {
    }

    public Student5(String in, String regist, String forgetCode) {
        this.in = in;
        this.regist = regist;
        this.forgetCode = forgetCode;

    }

    public String getIn() {
        return in;
    }

    public void setIn(String in) {
        this.in = in;
    }

    public String getRegist() {
        return regist;
    }

    public void setRegist(String regist) {
        this.regist = regist;
    }

    public String getForgetCode() {
        return forgetCode;
    }

    public void setForgetCode(String forgetCode) {
        this.forgetCode = forgetCode;
    }
}

  //  没有用到得类

判断字符串是否以0开头

newPersonId.startsWith("0");          // 判断字符串是否以龄开头

posted @ 2025-02-25 00:07 FoxDusk 阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 面向对象编程(oop)

· （基础+运算符+流程控制）相关案例和重点

· 面向对象基础

· Java面向对象知识点

· day07 7.1 Java中的面向对象之类与对象

阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 提示词工程——AI应用必不可少的技术
· Open-Sora 2.0 重磅开源！
· 周边上新：园子的第一款马克杯温暖上架

公告

昵称： FoxDusk
园龄： 2个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六