黑马程序员Java笔记（String开始）

2301_78736072

已于 2023-10-09 23:48:00 修改

阅读量918

点赞数 14

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

于 2023-10-08 23:55:34 首次发布

本文链接：https://blog.csdn.net/2301_78736072/article/details/133582806

版权

1. String

String类在java.lang包下，所以使用的时候不需要导包。

1.1 String构造方法

1.2 案例：用户登录

package string;

import java.util.Scanner;

public class string001 {
    public static void main(String[] args){
         // 已知用户名和密码
        String username = "Kobe";
        String password = "24&8";

        // 用循环实现多次机会，这里的次数明确，采用for循环实现
        for(int i=0; i<3; i++){

            // 键盘要录入登录的用户名和密码，用Scanner实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            // 用键盘录入的用户名和密码和已知的用户名和密码进行比较，并给出相应的提示
            if (username.equals(name) && password.equals(pwd)){
                System.out.println("登录成功");
                break;
            } else{
                if ((2-i) == 0){
                    System.out.println("登录失败，你的账号已被冻结！");
                } else{
                    System.out.println("用户名或密码输入错误，你还有" + (2-i) + "次输入机会！");
                }
            }
        }
    }
}

1.3 案例：遍历字符串

package string;

import java.util.Scanner;

public class string002 {
    public static void main(String[] args){
        // new一个Scanner对象接收输入的字符串
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        // 定义for循环，用charAt()方法遍历字符串
        for (int i=0; i< line.length(); i++){
            System.out.println(line.charAt(i));
        }
    }
————————————————
版权声明：本文为CSDN博主「浑水摸鱼大师」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_47626968/article/details/121589227

1.4substring

String substring(int beginIndex,int endIndex) 截取字符串中介于两个指定下标之间的字符。
注意：包头不包尾，包左不包右
      只有返回值才是街区的小串
String substring(int beginIndex) 截取到末尾

代码示例：

package String;

public class phone {
    public static void main(String[] args) {
        String phoneNumber="18867837498";
//        1.截取手机号前三位
       String three= phoneNumber.substring(0,3);

//        2.截取手机号后四位
        String severn=phoneNumber.substring(7);
        String str=three+"****"+severn;

        System.out.printf(str);
    }
}

1.5replace

String replace(旧值，新值）替换

注意：只有返回值才是替换后的结果

代码示例：

package String;

public class id {
    public static void main(String[] args) {
        String id="320891202005030495";
//    1.获取年
        String year=id.substring(6,10);
//        2.获取月
        String month=id.substring(10,12);
//        3.获取日
        String day=id.substring(12,14);
        System.out.printf("人物信息：");
        System.out.printf(year+"年"+month+"月"+day+"日");

//        4.获取17位
       char sex=id.charAt(16);
       //利用ASCII码表进行转换
        //’0‘=48 ’1‘=49
        //souf("0"+0)
       int i=sex-48;
        if(i%2==0){
            System.out.printf("性别为：女");
        }else {
            System.out.printf("性别为：男");
        }

    }
}

1.6 StringBuilder

1.6.1概述

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的

作用：提高字符串的操作效率

1.6.2 构造方法

1.6.3常用方法

1.6.4 创建StringBuilder

StringBuilder sb=new StringBuilder();

System.out.println(sb);

注：StringBuilder是java已经写好的类，java在底层中做了一些处理。所以打印对象不是地址值而是属性值

1.6.5代码演示

package StringBuilder;

public class demo1 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb= new StringBuilder("abd");

        //2.添加对象
        sb.append(1).append(12).append("LikeJave");

//      反转
        sb.reverse();

//        获取长度
        int len=sb.length();
        System.out.println(len);

        System.out.println(sb);

//        分割线
        StringBuilder sb1=new StringBuilder();

        //添加字符串
        sb1.append("aaaa").append("bbbb").append("cccc");
        System.out.println(sb1);//aaaabbbbcccc

        //再把Stringbuilder变回字符串
        String str = sb1.toString();

        System.out.println(str);//aaaabbbbcccc

    }
}

补充：链式编程

当调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法

1.6.6 案例判断对称

package StringBuilder;

import java.util.Scanner;

public class demo2 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个字符串");
        String str=sc.next();

        //2.反转键盘录入的字符串
        String result = new StringBuilder().append(str).reverse().toString();//toString将StringBuiler转换为字符串。

   if(str.equals(result)){
       System.out.println("当前字符串是对称字符串");
   }else{
       System.out.println("当前字符串不是对称字符串");
   }
    }
}

1.6.7 案例拼接字符串

package StringBuilder;

public class demo3 {
    public static void main(String[] args) {
       //1.定义数组
        int[] arr={1,2,3};

        //2.调用方法把数组变成字符串
       String str= arrtoString(arr);
        System.out.println(str);
    }

    public static String arrtoString(int[] arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i== arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]+",");
            }

        }
            sb.append("]");
            return sb.toString();
    }
}

1.7 Stringjoiner

1.7.1 概述

Stringjoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率，而且代码编写特别简洁。

1.7.2 构造方法

1.7.3 常用方法

1.7.4 代码示例

package Stringjoiner;

import java.util.StringJoiner;

public class demo1 {
    public static void main(String[] args) {
        //1.创建一个对象，并指定中间的建个符号
        StringJoiner sj=new StringJoiner(",","[","]");//注：Stringjoiner没有空参构造

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");//[aaa,bbb,ccc]
        System.out.println(sj);

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

        String str=sj.toString();
        System.out.println(str);
    }
}

2.集合

2.1集合和数组的对比

数组：长度固定。存储类型：基本数据类型、引用数据类型

集合：长度可变。存储类型：引用数据类型、包装类

2.2ArrayList

ArrayList是Java中已经写好的一个类，这个类在底层做了一些处，所以打印对象的时候不是打印地址值，而是集合中存储的数据内容，在展示的时候会拿[ ]把所有的数据进行包裹

2.3ArrayList成员方法

2.4代码示例

package ArrayList;

import java.util.ArrayList;

public class demo1 {
    public static void main(String[] args) {
        //1.创建对象
        ArrayList<String> list=new ArrayList<>();
        
        //2.添加元素
        list.add("aaaa");
        list.add("bbb");
        list.add("ccc");
        
        //3.删除元素
        boolean result = list.remove("aaaa");
        System.out.println(result);//true

        boolean result2 = list.remove("ddd");
        System.out.println(result2);//false
        
        //修改元素
        String ddd = list.set(1, "ddd");
        
        //查询元素
        String s = list.get(0);
        System.out.println(s);
        
        //遍历
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            System.out.println(str);
        }
    }
    
}

注：集合中表示长度的不是length，而是size（）方法。

2.5基本数据类型对应的包装类

2.6遍历打印数字

package ArrayList;

import java.util.ArrayList;

public class demo2 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<Integer> list =new ArrayList<>();
        //2.添加元素
        list.add(1);
        list.add(2);
        list.add(3);

        //3.遍历集合
        System.out.println("[");
        for (int i = 0; i < list.size(); i++) {
            if (i==list.size()-1){
                System.out.println(list.get(i));
            }else {
                System.out.println(list.get(i)+",");
            }
        }
        System.out.println("]");
    }
}

2.7 判断学生id

package ArrayList;

import java.util.ArrayList;

public class demo4 {
    public static void main(String[] args) {
        ArrayList<User> list=new ArrayList<>();

        //添加信息
        User u1=new User("001","l0l0","123456");
        User u2=new User("002","2020","1234567");
        User u3=new User("003","3030","12345678");

        list.add(u1);
        list.add(u2);
        list.add(u3);

        boolean flag=  contains(list,"004");
       int flag1= setIndex(list,"003");

        System.out.println(flag);
        System.out.println(flag1);
    }


    public static boolean contains(ArrayList<User> list,String id){

        if (setIndex(list, id)>=0){
            return true;
        }
       return false;
    }

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

3.Static

3.1概念

Static 表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量。

3.1.1静态变量

被static修饰的成员变量，叫做静态变量

特点：被该类所有对象共享

调用方式：类名调用、对象名调用

3.1.2静态方法

被static修饰的成员方法，叫做静态方法

特点：多用在测试类和工具类中，javaBe类中很少会用

调用方式：类名调用、对象名调用

3.2注意事项

1.静态方法只能访问静态变量和静态方法

2.非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法

3.静态方法中是没有this关键字

3.3工具类

帮助我们做一些事情的，但是不描述任何事物的类

javabean类：用来描述一类事物的类。比如，student，teacher，dog，cat等。

测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口

规则：1、类名见名知意 2、私有化构造方法 3、方法定义为静态

3.3定义数组工具类

package Static;

public class demo1 {
    public static void main(String[] args) {
        //测试工具类的两个方法是否正确
        int[] arr1={1,2,3,4,5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);


        double[]arr2={1.2,1.3,4.5,7.6};
        double average = ArrayUtil.getAverage(arr2);
        System.out.println(average);
    }
}

package Static;

public class ArrayUtil {

    //私有化构造方法
    //目的：为了不让外界创建它的对象
    private ArrayUtil(){
    }

    public static String printArr(int[]arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]+",");
            }
        }
        sb.append("]");
        return sb.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;
    }
}

4.继承

4.1概念

继承是面向对象三大特征之一，Java中提供一个关键字extends，用这个关键字，可以让类跟类之间产生子父（继承）的关系。

例：publi class Student extends Person{}

Student称为子类（派生类），person称为父类（基类或超类）

特点：java只支持单继承，不支持多继承，但支持多层继承。

单继承：一个子类只能继承一个父类。

不支持多继承：子类不能同时继承多个父类。

注：每一个类都直接或间接继承于object

4.2 使用

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

4.3继承内容

注：父类的构造方法不能被子类继承

子类可继承父类的成员变量和成员方法，但是成员方法只有父类的虚方法才能被子类继承，如果不能添加到虚方法，则不能被继承。

4.3.1成员变量

访问特点：

this调用：就近原则，先在局部位置找，本类成员位置找，父类成员位找，逐级往上。

super调用：直接找父类

4.3.2成员方法

访问特点：

直接调用满足就近原则：谁离我近，就调用谁。

4.3.2.1方法重写

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式：在继承体系中，子类出现了和父类中一摸一样的方法声明，我们就称子类这个方法是重写的方法。

注意事项和要求：

1.、重写方法的名称、形参列表必须与父类中的一致。

2、子类重写父类方法时，访问权限子类必须大于等于父类（空着不写<protected<pubilc）

3、子类重写父类方法时，返回值类型子类必须小于等于父类。

4、重写的方法尽量和父类保持一致。

5、只有被添加到虚方法表中的方法才能被重写。

4.3.2.2@Override重写注解

1@override是放在重写后的方法上，校验子类重写时语法是否正确，

2.加上注解后如果有红色波浪线，表示语法错误。

3.建议重写方法都加上@overrid，代码安全

4.4构造方法

访问特点：

1.父类的构造方法不会被子类继承，但是可以通过super调用

2.子类构造方法的第一行，有一个默认的super（）；

3.子类中所有的构造方法默认先访问父类中的无参构造，再执行自己

4.如果想要访问父类有参构造，必须手动书写

5.多态

5.1概念

面向对象三大特征之一，同类型的对象，表现出的不同形态

表现形式：

父类类型对象名称 =子类对象；

前提：

1.有继承/实现关系

2.有父类引用指向子类对象

3.有方法的重写

5.2好处

使用父类型作为参数，可以接受所有子类对象，体现多态的扩展性与便利。

5.3调用成员的特点

5.3.1成员变量

编译看左边，运行也看左边

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败

运行也看左边：Java运行代码的时候，实际获取的时左边父类中成员变量的值

5.3.2成员方法

编译看左边，运行看右边

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败

运行看右边：java运行代码的时候，实际运行的是子类中的方法

5.4优/劣势

优势：方法中，使用父类型作为参数，可以接受所有子类对象

劣势：无法使用子类的特有功能

5.5类型转换

引用数据类型转换有：自动类型转换、强制类型转换

5.5.1自动类型转换：

Person p =new Student();
Stduen s=(Student)p;

5.5.2强制类型转换

可以转换成真正的子类类型，从而调用子类独有功能

2.转换类型与真实对象类型不一致会报错

3.转换的时候用instanceof关键字进行判断

animal a=new dog();
animal b=new cat();

if(a instanceof dog d){
d.(子类独有方法）;
}else if(a instanceof cat c){
c.(子类独有方法);
}else{
System.out.println("没有这个类型，无法转换");
}

5.6final

修饰方法：表示该方法是最终方法，不能被重写

修饰类：表面类是最终类，不能被继承

修饰变量：叫做是常量，智能被赋值一次

5.6.1基本数据类型

final 修饰基本数据类型，记录的值不会发生改变

final double Pi=3.14;
Pi=4.13;//报错
System.out.println(Pi)//3.14

5.6.2引用数据类型

修饰引用数据类型，记录的地址值不会发生改变，内部的属性还是可以改变的

final Student s=new Student("zhangsan",24);
s.setName("lisi");
s.setAge(18);
System.out.println(s.getName+","+s.getAge)//lisi,18

5.7权限修饰符

有四种作用范围由小到大（private<空着不写<proteced<public)

实际开发过程中，一般只用private和public

一般是成员变量私有化，方法公开化。

特例：如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。

5.8代码块

代码块：局部代码块、构造代码块、静态代码块

局部代码块的作用：提前结束变量的生命周期（已淘汰）

构造代码块的作用：抽取构造方法中的重复代码（不够灵活）

静态代码块的作用：数据的初始化

6.抽象方法

6.1概念

将共性的行为（方法）抽取到父类之后由于每一个子类执行的内容是不一样的的，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

6.2抽象类

如果一个类存在抽象方法，那么该类就必须声明为抽象类

6.3定义格式

public abstract class 类名{}

6.4 注意事项

1.抽象类不能实例化

2.抽象类中不一定由抽象方法，由抽象方法的类一定是抽象类

3.抽象类可以有构造方法

4抽象类的子类要么重写抽象类的所由抽象方法，要么是抽象类

7.接口

7.1概念

接口就是一种规则，是对行为的抽象

7.2定义和使用

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

public interface 接口名{}

2.接口不能实例化

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

public class 类名 implement 接口名{}

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

要么重写接口中的所有抽象方法，要么自己就是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现。

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

注意2：实现类还可以在继承一个类的同时实现多个接口

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

7.3成员的特点

1.成员变量：

只能是常量

默认修饰符：public static final

2.没有构造方法

3.成员方法：

只能是抽象方法

默认修饰符：public abstract

7.4接口与类之间的关系

1.类与类的关系：

继承关系，只能单继承，不能多继承，但是能多层继承

2.类与接口的关系

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

3.接口与接口的关系

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

如果接口1继承了接口2、3、4。并且与类实现了接口关系，那么这个类需要重写包括接口1在内的所有他所继承的接口的抽象方法

7.5代码实现

思路图

person

package interfaces;

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

    public person() {
    }

    public person(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;
    }
}

教练

package interfaces;

public abstract class coach extends person{
    public coach() {
    }

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

    public abstract void teach();//教
}

运动员

package interfaces;

public abstract class Sporter extends person{
    public Sporter() {
    }

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

    public abstract void learn();//
}

接口

package interfaces;

public interface speakEnglish {
    public abstract void English();
}

乒乓球运动员

package interfaces;

public class pingpangSporter extends Sporter implements speakEnglish{
    public pingpangSporter() {
    }

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

    @Override
    public void learn() {
        System.out.println("运动员正在学乒乓球");
    }

    @Override
    public void English() {
        System.out.println("运动员正在说英语");
    }
}

篮球运动员

package interfaces;

public class pingpangSporter extends Sporter implements speakEnglish{
    public pingpangSporter() {
    }

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

    @Override
    public void learn() {
        System.out.println("运动员正在学乒乓球");
    }

    @Override
    public void English() {
        System.out.println("运动员正在说英语");
    }
}

乒乓球教练

package interfaces;

public class pingpangCoach extends coach{
    public pingpangCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("教练正在教乒乓球");
    }
}

篮球教练

package interfaces;

public class basketballCoach extends coach{
    public basketballCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("教练正在教篮球");
    }
}

测试类

package interfaces;

public class text {
    public static void main(String[] args) {
        pingpangCoach pc=new pingpangCoach("刘国栋",48);
        System.out.println(pc.getName()+","+pc.getAge());
        pc.teach();

        pingpangSporter ps=new pingpangSporter("许昕",25);
        System.out.println(ps.getName()+","+ps.getAge());
        ps.learn();
        ps.English();


    }
}

个人感受：这个例子很好的结合了抽象方法和接口

7.6拓展内容

此内容是JDK8以后接口中新增的方法

7.6.1默认方法

默认方法使用，需要用default关键字修饰

作用：解决接口升级的问题

7.6.1.1定义格式

public default 返回值类型 方法名（参数列表）{}

示例：

public default void show{}

7.6.1.2注意事项

1.默认方法不是抽象方法，所以不强制重写。但是如果要重写，重写时去掉default关键字

2.public可以省略，default不能省略

3.如果实现了多个接口，多个接口存在相同名字的默认方法，子类就必须对该方法进行重写

7.6.2静态方法

使用静态方法需要用static修饰

7.6.2.1定义格式

public static返回值类型 方法名（参数列表）{}

示例：

public static void show(){}

7.6.2.2注意事项

1.静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

2.public可以省略，static不能省略（如果省略会被当做抽象方法）

7.6.3私有方法

7.6.3.1定义格式

格式1

private 返回值类型 方法名（参数类型）{}

示例：

private void show(){}

格式2

private static 返回值类型 方法名（参数类型）{}

示例

private static void show(){}

总结：私有方法分两种普通私有方法，静态的私有方法

7.7适配器

当一个接口中抽象方法过多，但是我只要其中一部分的时候，就可以用到适配器设计模式

书写步骤：

编写中间类XXXadapte，实现对应的接口对接口中的抽象方进行空实现，让真正的实现类继承中间类，并重写需要用的方法，为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

8.内部类

8.1概念

写在一个类里面的类就叫做内部类

什么时候用到：B类表示的事物是A类的一部恶法你，且B单独存在没有意义。

例：在A类的内部定义B类，B类就被称为内部类

访问特点：

1.内部类可以直接访问外部类的成员，包括私有

2.外部类要访问内部类的成员，必须创建对象

8.2代码实现

package Inter;

public class Car {
    String carName;
    int carAge;
    String carColor;

    public void show(){
        System.out.println(carName);
        Engine e=new Engine();
        System.out.println(e.engineName);
    }

    static class Engine{
        String engineName;
        int engineAge;
        public void show(){
            System.out.println(engineAge);
            System.out.println(carAge);
        }
    }
}

package Inter;

public class Text {
    public static void main(String[] args) {
        Car c=new Car();
        c.carName="宾利";
        c.carAge=1;
        c.carColor="红色";
        c.show();
        Car.Engine e=new Car.Engine();
        e.engineName="1";
        e.engineAge=12;
        e.show();

    }
}

2301_78736072

关注

14
点赞
踩
28

收藏

觉得还不错? 一键收藏
1
评论
黑马程序员Java笔记（String开始）

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的作用：提高字符串的操作效率Stringjoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。作用：提高字符串的操作效率，而且代码编写特别简洁。//测试工具类的两个方法是否正确//私有化构造方法//目的：为了不让外界创建它的对象i++) {}else {i++) {public abstract class 类名{}
复制链接

扫一扫