菜鸟追梦旅行

这个屌丝很懒，什么也没留下！

热门标签

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

作者：菜鸟追梦旅行 | 2024-03-16 02:36:35

踩

代码笔记

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/246421

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

1. String

1.1 String构造方法

1.2 案例：用户登录

1.3 案例：遍历字符串

1.4substring

1.5replace

1.6 StringBuilder

1.6.1概述

1.6.2 构造方法

1.6.3常用方法

1.6.4 创建StringBuilder

1.6.5代码演示

1.6.6 案例 判断对称

1.6.7 案例 拼接字符串

1.7 Stringjoiner

1.7.1 概述

1.7.2 构造方法

1.7.3 常用方法

1.7.4 代码示例

2.集合

2.1集合和数组的对比

2.2ArrayList

2.3ArrayList成员方法

2.4代码示例

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

2.6遍历打印数字

2.7 判断学生id

3.Static

3.1概念

3.1.1静态变量

3.1.2静态方法

3.2注意事项

3.3工具类

3.3定义数组工具类

4.继承

4.1概念

4.2 使用

4.3继承内容

4.3.1成员变量

4.3.2成员方法

4.3.2.1方法重写

4.3.2.2@Override重写注解

4.4构造方法

5.多态

5.1概念

5.2好处

5.3调用成员的特点

5.3.1成员变量

5.3.2成员方法

5.4优/劣势

5.5类型转换

5.5.1自动类型转换：

5.5.2强制类型转换

5.6final

5.6.1基本数据类型

5.6.2引用数据类型

5.7权限修饰符

5.8代码块

6.抽象方法

6.1概念

6.2抽象类

6.3定义格式

6.4 注意事项

7.接口

7.1概念

7.2定义和使用

7.3成员的特点

7.4接口与类之间的关系

7.5代码实现

7.6拓展内容

7.6.1默认方法

7.6.1.1定义格式

7.6.1.2注意事项

7.6.2静态方法

7.6.2.1定义格式

7.6.2.2注意事项

7.6.3私有方法

7.6.3.1定义格式

7.7适配器

1.6.6 案例判断对称

1.6.7 案例拼接字符串