黑马程序员java笔记

青城山顶避雷针

已于 2023-08-01 11:28:52 修改

阅读量721

点赞数 2

文章标签： java 笔记开发语言

于 2023-07-31 09:49:43 首次发布

本文链接：https://blog.csdn.net/weixin_74332465/article/details/132014988

版权

对象数组

//创建对象数组语法

类名[]数组名=类名[对象个数]

/*定义一个长度为3的数组，数组存储1~3名学生对象作为初始数据，学生对象的学号，姓名各不相同。
        学生的属性：学号，姓名，年龄。
        要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
        要求2：添加完毕之后，遍历所有学生信息。

        要求3：通过id删除学生信息
        如果存在，则删除，如果不存在，则提示删除失败。
        要求4：删除完毕之后，遍历所有学生信息。
        要求5：查询数组id为“heima002”的学生，如果存在，则将他的年龄+1岁*/

创建学生类的javabean

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

    public Student() {
    }

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

任务1：添加一个学生对象并利用学号判断其唯一性

pulic class text{
public static voidf main(string[] args){
//创建一个对象数组
Student[] arr=new Student[3];
//创建学生对象
 Student stu1 = new Student(1, "zhangsan", 23);
 Student stu2 = new Student(2, "lisi", 24);
//把学生对象添加到数组中去,对数组元素进行赋值
arr[0] = stu1;
arr[1] = stu2;

//要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断。
        Student stu4 = new Student(1, "zhaoliu", 26);
//判断唯一性
//存在则显示存在不予添加
//不存在则添加到数组中去

是否则利用到boolean函数
//定义boolean 函数传入contains方法的结果
boolean falg=contains(arr, stu4.getId());
if(flag){
System.out.println("当前id重复，请修改id后再进行添加")
else{
//添加时还要判断数组是否装满
int count= int count = getCount(arr);//设置变量来记录数组实际的长度
 if(count == arr.length){
//创建一个新的数组，长度 = 老数组的长度 + 1
//然后把老数组的元素，拷贝到新数组当中
Student[] newArr = creatNewArr(arr);
//把stu4添加进去
newArr[count] = stu4;

//要求2：添加完毕之后，遍历所有学生信息。
printArr(newArr);//调用遍历函数

}else{
//没有存满
//[stu1,stu2,null]
//getCount获取到的是2，表示数组当中已经有了2个元素
//还有一层意思：如果下一次要添加数据，就是添加到2索引的位置
arr[count] = stu4;
//要求2：添加完毕之后，遍历所有学生信息。
printArr(arr);
      }
    }
  }
//定义遍历数组的函数
//定于函数时
 //1.我要干嘛？  唯一性判断
 //2.我干这件事情，需要什么才能完成？ 数组 id
 //3.调用处是否需要继续使用方法的结果？ 必须返回
 public static void printArr(Student[] arr) {
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];//设置对象去等于这个临时的数组
            if (stu != null) {
                System.out.println(stu.getId() + ", " + stu.getName() + ", " + stu.getAge());
            }
        }
    }
public static Student[] creatNewArr(Student[] arr){
        Student[] newArr = new Student[arr.length + 1];

        //循环遍历得到老数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //把老数组中的元素添加到新数组当中
            newArr[i] = arr[i];
        }

        //把新数组返回
        return newArr;

    }
//定义一个方法判断数组中已经存了几个元素
    public static int getCount(Student[] arr){
        //定义一个计数器用来统计
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] != null){
                count++;
            }
        }
        //当循环结束之后，我就知道了数组中一共有几个元素
        return count;
    }
 public static boolean contains(Student[] arr, int id) {
        for (int i = 0; i < arr.length; i++) {
            //依次获取到数组里面的每一个学生对象
            Student stu = arr[i];
            if(stu != null){
                //获取数组中学生对象的id
                int sid = stu.getId();
                //比较
                if(sid == id){
                    return true;
                }
            }
        }

        //当循环结束之后，还没有找到一样的，那么就表示数组中要查找的id是不存在的。
        return false;
    }
}

任务2：通过id删除学生信息如果存在，则删除，如果不存在，则提示删除失败。

//前期创建好数组
//利用函数遍历数组中元素判断元素是否存在
int index=getIndex(arr, 2);//设置变量存储索引值，存在则删除
 if (index >= 0){
 //如果存在，则删除
 arr[index] = null;
 //遍历数组
 printArr(arr);
 }else{
 //如果不存在，则提示删除失败
System.out.println("当前id不存在，删除失败");
 }
public static int getIndex(Student[] arr , int id){//传入数组中元素和要寻找到id
        for (int i = 0; i < arr.length; i++) {
            //依次得到每一个学生对象
            Student stu = arr[i];
            //对stu进行一个非空判断
            if(stu != null){
                int sid = stu.getId();
                if(sid == id){
                    return i;//若找到id则返回索引值
                }
            }
        }

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

随机数的使用

创建一个格斗小游戏使用随时数生成伤害值

 //定义随机数的变量
Random r = new Random();//生成随机数
if (gender == '男') {
            //从boyfaces里面随机长相
//定义index 变量存储随机数，并限制了随机数的范围 
            int index = r.nextInt(boyfaces.length);
            this.face = boyfaces[index];//设置的容貌就为男容貌字符串数组中的随机数据

字符串String

创建方式：

1.直接赋值String name="我是字符串"

2.new创建

字符串存储方式

public class StringDemo{

public static void main(String []args)

String s1="abc"

String s2="abc"}

//代码开始运行

1.方法入栈

创建出s1则观察串池中是否有abc 则在串池中创建

创建s2时则串池中有直接赋值

public class StringDemo{

public static void main(String []args)

String s1=new String("abc")

String s2=new String("abc")}

只要有new 就会在堆内开辟新地址，则不会复用地址则比较浪费空间

字符串的比较

==号比较的内容

基本数据类型	引用数据类型
String s1="abc"	String s1=new String("abc")
比较数据值	比较地址值

字符串比较方法（常用于密码的设置）

boolean aquals方法完全一样才返回true

boolean equalslgnoreCase 忽略大小写的比较

import java.util.Scanner;

public class StringDemo4 {
    public static void main(String[] args) {
        //读题拆解法

        //1.定义两个变量记录正确的用户名和密码
        String rightUsername = "zhangsan";
        String rightPassword = "123456";


        Scanner sc = new Scanner(System.in);
        //2.键盘录入用户名和密码
        for (int i = 0; i < 3; i++) {// 0 1 2
            System.out.println("请输入用户名");
            String username = sc.next();
            System.out.println("请输入密码");
            String password = sc.next();

            //3.比较
            if (username.equals(rightUsername) && password.equals(rightPassword)) {
                System.out.println("用户登录成功");
                break;
            } else {
                if(i == 2){
                    //最后一次机会也输入错误，此时要提示账号被锁定
                    System.out.println("账号" + username + "被锁定，请联系黑马程序员官方客服小姐姐:XXX-XXXXX");
                }else{//密码次数是要减少的
                    System.out.println("用户登录失败，用户名或密码有误,您还剩下" + (2 - i) + "次机会");//2 1 0
                }
            }
        }

    }
}

字符串的遍历

str.length()//计算字符串的长度是一个方法所以有（）
str.charAt(i);//循环遍历的方法

import java.util.Scanner;

public class StringDemo5 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.进行遍历
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串的每一个索引
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}
//输入abc
//生成为
//a
//b
//c

字符串遍历并对大小写及数字进行统计

package com.itheima.stringdemo;

import java.util.Scanner;

public class StringDemo6 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.统计--- 计数器思想
        //定义三个计数器
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串中的每一个索引
            char c = str.charAt(i);
            if(c >= 'a' && c <= 'z'){
                //char类型的变量在参与计算的时候自动类型提升为int 查询ascii码表
                smallCount++;
            }else if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }

        //3.输出打印
        System.out.println("小写字母有：" + smallCount + "个");
        System.out.println("大写字母有：" + bigCount + "个");
        System.out.println("数字字母有：" + numberCount + "个");
    }
}

//看似是比较字母实则是会换算成ASCII码进行比较

字符串的反转

package com.itheima.stringdemo;

public class StringDemo8 {
    public static void main(String[] args) {
        String result = reverser("abc");
        System.out.println(result);
    }


    //1.我要干嘛？  --- 字符串的反转
    //2.我干这件事情，需要什么才能完成？  --- 需要一个字符串
    //3.调用处是否需要继续使用方法的结果呢？ ---需要结果进行输出
    public static String reverser(String str){
        String result = "";
        for (int i = str.length() - 1; i >= 0; i--) {//倒着遍历
            //i 依次表示字符串中的每一个索引 （倒着的）
            char c = str.charAt(i);
            result = result + c;//字符的拼接
        }
        return result;
    }
}

查表法金额转换

package com.itheima.stringdemo;

import java.util.Scanner;

public class StringDemo9 {
    public static void main(String[] args) {
        //1.键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while (true) {
            System.out.println("请录入一个金额");
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {
                break;
            } else {
                System.out.println("金额无效");
            }
        }

        //定义一个变量用来表示钱的大写
        String moneyStr = "";

        //定义一个循环来转换出大写的数字
        while (true) {//2135
           //逐步获取各个位数
            int ge = money % 10;
            //利用查表发转换大写书数字
            String capitalNumber = getCapitalNumber(ge);
            //把转换之后的大写拼接到moneyStr当中
            moneyStr = capitalNumber + moneyStr;
            money = money / 10;//去除已经转换完的位数
            //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
            if (money == 0) {
                break;
            }
        }

        //金额转换进行补零
        //3.在前面补0，补齐7位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);//零零零贰壹叁伍

        //4.插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零    零   零   贰   壹   叁   伍

        //遍历moneyStr，依次得到 零    零   零   贰   壹   叁   伍
        //然后把arr的单位插入进去

        String result = "";//定于最终结果字符串
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result当中
            result = result + c + arr[i];//进行插入拼接
        }

        //5.打印最终结果
        System.out.println(result);

    }


    //定义一个方法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number) {
        //定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        //返回结果
        return arr[number];
    }

}

手机号屏蔽

package com.itheima.stringdemo;

public class StringDemo10 {
    public static void main(String[] args) {
        //1.获取一个手机号码
        String phoneNumber = "13112349468";

        //2.截取手机号码前面三位
        String start = phoneNumber.substring(0, 3);

        //3.截取手机号码后面四位
        String end = phoneNumber.substring(7);

        //4.拼接
        String result = start + "****" + end;

        //5.打印
        System.out.println(result);


    }
}

关键字的屏蔽

package com.itheima.stringdemo;

public class StringDemo13 {
    public static void main(String[] args) {
        //1.获取到说的话
        String talk = "你玩的真好，以后不要再玩了，TMD,CNM";


        //2.定义一个敏感词库
        String[] arr = {"TMD","CNM","SB","MLGB"};


        //3.循环得到数组中的每一个敏感词，依次进行替换
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i], "***");
        }

        //4.打印结果
        System.out.println(talk);
    }
}

StringBuilder

可以看作一个容器，可更改

package com.itheima.stringbuilderdemo;

public class StringBuilderDemo2 {
    public static void main(String[] args) {
//创建一个stringbuilider数组
        StringBuilder sb = new StringBuilder();
//利用数组名引出方法
        for (int i = 0; i < 1000000; i++) {
            sb.append("abc");
        }

        System.out.println(sb);
    }
}

Stringjoiner

利于添加

//1.创建一个对象，并指定中间的间隔符号
        StringJoiner sj = new StringJoiner("---");

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");


        //3.打印结果
        System.out.println(sj);//aaa---bbb---ccc
//1.创建对象
        StringJoiner sj = new StringJoiner(", ","[","]");

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");

        int len = sj.length();
        System.out.println(len);//15

        //3.打印
        System.out.println(sj);//[aaa, bbb, ccc]

        String str = sj.toString();
        System.out.println(str);//[aaa, bbb, ccc]

字符串拼接底层原理

107-110

集合

与数组相比，集合长度可变，且自动变化

可直接存储引用数据类型，想要存储基本数据类型需要将其变成包装类

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

泛型

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

        //1.创建一个集合
        ArrayList<String> list = new ArrayList<>();

        //2.添加元素
        list.add("aaa");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");


        //3.删除元素
      /*  boolean result1 = list.remove("aaa");
        System.out.println(result1);

        boolean result2 = list.remove("ddd");
        System.out.println(result2);

        String str = list.remove(2);
        System.out.println(str);*/


        //修改元素
        /*String result = list.set(1, "ddd");
        System.out.println(result);*/

        //查询元素
       /* String s = list.get(0);
        System.out.println(s);*/

        //遍历
        for (int i = 0; i < list.size(); i++) {
            //i 索引
            //list.get(i) 元素
            String str = list.get(i);
            System.out.println(str);
        }



    }
}

集合练习

//创建一个javabean
//实现容器存储对象
ublic class Test4 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<Student> list = new ArrayList<>();

        //2.创建学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);

        //3.添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //4.遍历集合
        for (int i = 0; i < list.size(); i++) {
            //i 索引 list.get(i) 元素/学生对象
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

public class Test5 {
//键盘录入对象元素
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<Student> list = new ArrayList<>();
        //长度为0
        //2.键盘录入学生的信息并添加到集合当中
        Scanner sc = new Scanner(System.in);
        Student s = new Student();
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入学生的姓名");
            String name = sc.next();
            System.out.println("请输入学生的年龄");
            int age = sc.nextInt();

            //把name和age赋值给学生对象
            s.setName(name);
            s.setAge(age);

            //把学生对象添加到集合当中
            list.add(s);
        }
        //3.遍历
        for (int i = 0; i < list.size(); i++) {
            //i 索引 list.get(i) 元素/学生对象
            Student stu = list.get(i);
            System.out.println(stu.getName() + ", " + stu.getAge());
        }
    }
}

/*需求：
1，main方法中定义一个集合，存入三个用户对象。
用户属性为：id，username，password
2，要求：定义一个方法，根据id查找对应的用户信息。
如果存在，返回true
如果不存在，返回false*/
public class Test6 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<User> list = new ArrayList<>();

        //2.创建三个用户对象
        User u1 = new User("heima001","zhangsan","123456");
        User u2 = new User("heima002","lisi","12345678");
        User u3 = new User("heima003","wangwu","1234qwer");

        //3.把用户对象添加到集合当中
        list.add(u1);
        list.add(u2);
        list.add(u3);

        //4.调用方法查看id是否存在
        boolean flag = contains(list, "heima0010");

        //5.打印结果
        System.out.println(flag);

    }

    //1.我要干嘛？   根据id查找用户
    //2.我干这件事需要什么才能完成？   list  id
    //3.调用处是否需要使用方法的结果？ 返回
    public static boolean contains(ArrayList<User> list, String id){
       /* for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);//创建新对象存储，循环遍历容器中的元素
            String uid = u.getId();
            if(uid.equals(id)){
                //如果找到了直接返回true
                return true;
            }
        }
        //当循环结束表示集合里面所有的元素都已经比较完毕，还没有一样的，那么返回false就可以了
        return false;*/

       return getIndex(list,id) >= 0;

    }


    public static int getIndex(ArrayList<User> list, String id) {
        for (int i = 0; i < list.size(); i++) {
            User u = list.get(i);
            String uid = u.getId();
            if(uid.equals(id)){
                return i;
            }
        }

        return -1;
    }
}

面向对象程序设计进阶

Static静态

静态成员被所有类的对象共享，不属于对象属于类，优先于对象存在

静态方法只能访问静态，非静态方法可访问静态，静态方法无this关键字

调用方法：类名调用，对象名调用

1.程序启动main 方法进栈

2.执行第一行代码，用到第一个类，把类的字节码文件（包括成员变量，注意静态变量存储在堆内存的静态区中）加载到方法区，变量会根据代码被赋值

3.运行下一行代码，用到方法加载方法区方法进栈，继续加载，因为静态优先于对象存在则对象未在堆内开辟空间存储变量所以无法引用

main重识

继承

多态

接口

接口不是一类事物，他是一类规则，对行为的抽象，与抽象类不同

1.接口用关键字interface来定义

public interface 接口名{}

2.接口不能实例化

3.接口和类之间是实现关系，通过implements关键字来表示

public class 类名 implements 接口名{}

4.接口的子类（实现类）

要么重写接口所有方法

要么抽象类

接口中成员的特点

//编写带有接口和抽象类的标准javabean
package com.itheima.a01interfacedemo1;
 //动物类
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();
 
}
//狗类
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("狗刨");
    }
//青蛙类
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("青蛙在蛙泳");
    }
//兔子类
public class Rabbit extends Animal{
 
 
    public Rabbit() {
    }
 
    public Rabbit(String name, int age) {
        super(name, age);
    }
 
    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }

//游泳的接口
package com.itheima.a01interfacedemo1;
 
public interface Swim {
 
    public abstract void swim();
 
 
}
//测试类
package com.itheima.a01interfacedemo1;
 
 
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();
 
 
    }
}