适合Java期末的复习~
（Java期末复习知识点总结分为4篇，这里是最后一篇啦）第一篇~
https://blog.csdn.net/qq_53869058/article/details/129417537?spm=1001.2014.3001.5501第二篇~https://blog.csdn.net/qq_53869058/article/details/129475124?spm=1001.2014.3001.5501第三篇~https://blog.csdn.net/qq_53869058/article/details/129516371?spm=1001.2014.3001.5501
目录
一、抽象类
1. 抽象类的产生背景
2. 抽象类语法
3. 抽象类特性
二、接口
1. 接口语法
2. 接口特性
3. 实现多个接口
4. 接口间的继承
5. 对比一下抽象类与接口
三、String类
1. 字符串构造
2. String对象的比较
3. 字符串查找
4. 转化
5. 字符串替换
6. 字符串拆分
7. 字符串截取
一、抽象类
1. 抽象类的产生背景
1.多态的实现需要依赖继承与方法重写，但是前面的方式我们无法对子类是否重写方法做出要求，子类到底重写方法与否，重写哪些方法，全凭自愿，若需要对子类重写方法做出一些强制性的要求，就会用到抽象类
2.很多父类其实本身就是抽象的，只有在具体子类中方法才有具体含义，这些类也应当被定义为抽象类
2. 抽象类语法
在 Java 中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。
// 抽象类：被abstract修饰的类
public abstract class Shape {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。
3. 抽象类特性
3.1 抽象类不能直接实例化对象，抽象类必须有子类，抽象类不能自己实例化对象，要通过子类对象向上转型为其实例化
Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化3.2 抽象方法不能是 private 的
抽象方abstract class Shape {
abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private3.3 抽象方法不能被fifinal和static修饰，因为法要被子类重写
public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
}
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static3.4 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
// 矩形类
public class Rect extends Shape {
private double length;
private double width;
Rect(double length, double width){
this.length = length;
this.width = width;
}
public void draw(){
System.out.println("矩形: length= "+length+" width= " + width);
}
public void calcArea(){
area = length * width;
}
}//圆类
public class Circle extends Shape{
private double r;
final private static double PI = 3.14;
public Circle(double r){
this.r = r;
}
public void draw(){
System.out.println("圆：r = "+r);
}
public void calcArea(){
area = PI * r * r;
}
}// 三角形类：
public abstract class Triangle extends Shape {
private double a;
private double b;
private double c;
@Override
public void draw() {
System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
}
// 三角形：直角三角形、等腰三角形等，还可以继续细化
//@Override
//double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
}3.5 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
3.6 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
3.7子类也是抽象类，可以选择性的重写抽象方法，即子类可以一个抽象方法都不重写
二、接口
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用 。 在 Java 中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
1. 接口语法
接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
}【提示】
1. 创建接口时 , 接口的命名一般以大写字母 I 开头 .
2. 接口的命名一般使用 " 形容词" 词性的单词 .
3. 阿里编码规范中约定 , 接口中的方法和属性不要加任何修饰符号 , 保持代码的简洁性
public class 类名称 implements 接口名称{
// ...
}【注意】
子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
子类的命名 : 以父类接口名称开头，以impl结尾
Messagelmpl => 一眼看上去就知道是IMessage接口的子类
实现一个笔记本电脑使用 USB 鼠标、 USB 键盘的例子：
1. USB 接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用 USB 设备功能
3. 鼠标类：实现 USB 接口，并具备点击功能
4. 键盘类：实现 USB 接口，并具备输入功能
// USB接口
public interface USB {
void openDevice();
void closeDevice();
}// 鼠标类，实现USB接口
public class Mouse implements USB {
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("鼠标点击");
}
}// 键盘类，实现USB接口
public class KeyBoard implements USB {
@Override
public void openDevice() {
System.out.println("打开键盘");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘");
}
public void inPut(){
System.out.println("键盘输入");
}
}// 笔记本类：使用USB设备
public class Computer {
public void powerOn(){
System.out.println("打开笔记本电脑");
}
public void powerOff(){
System.out.println("关闭笔记本电脑");
}
public void useDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyBoard = (KeyBoard)usb;
keyBoard.inPut();
}
usb.closeDevice();
}
}// 测试类：
public class TestUSB {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
// 使用鼠标设备
computer.useDevice(new Mouse());
// 使用键盘设备
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}2. 接口特性
2.1 接口类型是一种引用类型，但是不能直接new接口的对象
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化2.2 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}2.3 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
public interface USB {
void openDevice();
// 编译失败：因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");
}
}2.4 重写接口中方法时，不能使用默认的访问权限
public interface USB{
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
// ...
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public4.5 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
4.6 接口中不能有静态代码块和构造方法
4.7 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
3. 实现多个接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面是子类继承父类与实现多个接口的语法：
class 子类 extends 父类 implements 接口1, 接口2,...,接口n{
//...
}4. 接口间的继承
//接口1继承接口2和接口3
interface 接口1 extends 接口2, 接口3 {
}5. 对比一下抽象类与接口
三、String类
String类的常用方法
1. 字符串构造
String 类提供的构造方式非常多，常用的就以下三种：
public static void main(String[] args) {
// 使用常量串构造
String s1 = "hello bit";
System.out.println(s1);
// 直接newString对象
String s2 = new String("hello bit");
System.out.println(s1);
// 使用字符数组进行构造
char[] array = {'h','e','l','l','o','b','i','t'};
String s3 = new String(array);
System.out.println(s1);
}【 注意 】
（1）String 是引用类型，内部并不存储字符串本身
public static void main(String[] args) {
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;
System.out.println(s1.length()); // 获取字符串长度---输出5
System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
}（2）在Java中“”引起来的也是String类型对象
// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());2. String对象的比较
字符串的比较是常见操作之一，比如：字符串排序。 Java 中总共提供了 4 中方式：
2.1 == 比较是否引用同一个对象
注意：对于内置类型， == 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4);2.2 boolean equals(Object anObject) 方法按照字典序比较（需要自己重写）
2.3 int compareTo(String s) 方法 : 按照字典序进行比较（需要自己重写）
（这两个一般不会考到，知道就好）
3. 字符串查找
字符串查找也是字符串中非常常见的操作， String 类提供的常用查找的方法：
public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3)); // 'b'
System.out.println(s.indexOf('c')); // 6
System.out.println(s.indexOf('c', 10)); // 15
System.out.println(s.indexOf("bbb")); // 3
System.out.println(s.indexOf("bbb", 10)); // 12
System.out.println(s.lastIndexOf('c')); // 17
System.out.println(s.lastIndexOf('c', 10)); // 8
System.out.println(s.lastIndexOf("bbb")); // 12
System.out.println(s.lastIndexOf("bbb", 10)); // 3
}4. 转化
4.1 数值和字符串转化
public static void main(String[] args) {
// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("Hanmeimei", 18));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println("=================================");
// 字符串转数字
// 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}4.2 大小写转换
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}4.3 字符串转数组
public static void main(String[] args) {
String s = "hello";
// 字符串转数组
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
// 数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}5. 字符串替换
//字符串的替换处理
String str = "helloworld" ;
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));注意 : 由于字符串是不可变对象 , 替换不修改当前字符串 , 而是产生一个新的字符串
6. 字符串拆分
可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
可用方法如下：
//拆分IP地址
String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}7. 字符串截取
从一个完整的字符串之中截取出部分内容。可用方法如下:
//字符串截取
String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));【 注意 】
1. 索引从 0 开始
2. 注意前闭后开区间的写法 , substring(0, 5) 表示包含 0 号下标的字符 , 不包含 5 号下标
看完啦
祝各位期末通通过！！！
