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