1. String
String类在java.lang包下，所以使用的时候不需要导包。
1.1 String构造方法
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版权协议，转载请附上原文出处链接及本声明。原文链接：/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="32089120030495";// 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);//15String 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);//trueboolean 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","","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);}@Overridepublic void learn() {System.out.println("运动员正在学乒乓球");}@Overridepublic 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);}@Overridepublic void learn() {System.out.println("运动员正在学乒乓球");}@Overridepublic void English() {System.out.println("运动员正在说英语");}}
乒乓球教练
package interfaces;public class pingpangCoach extends coach{public pingpangCoach() {}public pingpangCoach(String name, int age) {super(name, age);}@Overridepublic void teach() {System.out.println("教练正在教乒乓球");}}
篮球教练
package interfaces;public class basketballCoach extends coach{public basketballCoach() {}public basketballCoach(String name, int age) {super(name, age);}@Overridepublic 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();}}
