day_10
1、面向对象_3【重点】
1.1、继承【重点】
1.1.1、语法格式
class 子类 extends 父类 {
//类体
}
1.1.2、总结
- Java中的继承关系都是单继承，也可以多重继承
- 成员变量(属性)和成员方法：公共的(public)和默认的(default)属性子类可以继承，私有的(private)属性子类无法继承
- 构造方法：如果父类没有无参构造方法时，子类的构造方法至少有一个参数列表与父类的构造方法保持一致，如果父类中有无参的构造方法时，子类的构造方法可以与父类的构造方法的参数列表都不相同。执行过程：先执行父类的构造方法，再执行子类的构造方法
- 私有的成员变量(属性)调用：通过私有属性的getXxx()和setXxx()方法访问私有属性
1.2、父类和子类的内存解析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-20YqZRIP-1659343917616)(images\子类和父类的内存解析.png)]
1.3、方法重载与方法重写【重点】【面试题】
1.3.1、方法重载(overload)
- 必须在同一个类中
- 方法名相同
- 方法的参数列表不相同
- 方法的返回值类型、权限修饰符可以不相同
- 无参构造和有参构造也是方法重载
1.3.2、方法重写(override)
- 必须有继承关系，在子类中重写
- 父类的方法必须是非私有化
- 方法的方法名、返回值类型、参数列表相同
- 权限修饰符可以不相同，但子类重写方法的访问权限不能低于父类被重写方法的访问权限
day_11
1、面向对象_4【重点】
1.1、关键字：super
1.1.1、语法格式
//普通方法调用父类的属性(成员变量)和成员方法【不常用】
super.属性名;
super.方法名();
//构造方法调用父类的构造方法
super();
super(参数1,参数2,参数3,...);
1.1.2、总结
- super关键字代表父类对象
- super关键字只能在方法(成员方法或构造方法)中使用
- super关键字可以在构造方法和成员方法中调用父类的属性(成员变量)和成员方法
- super关键字可以调用构造方法，但只能在构造方法中调用构造方法，并且只能写在第一行
1.2、抽象类【重点】
1.2.1、语法格式
abstract class 类名 {
//属性
//构造方法【不常用】
//普通方法
//抽象方法
public abstract void 方法名();
public abstract 数据类型 方法名();
}
1.2.2、总结
- 抽象类中主要有属性、普通方法、抽象方法等
- 抽象方法没有方法体，抽象类不能被实例化
- 子类必须要重写抽象类中所有抽象方法，非抽象方法可以重写也可以不重写
- 普通类可以继承抽象类，抽象类可以继承抽象类，抽象类也可以继承普通类
1.3、关键字：final
1.3.1、语法格式
//final关键字修饰成员变量
class 类名 {
final 数据类型 变量名 = 变量值;
//
}
//final关键字修饰局部变量
class 类名 {
public void 方法名() {
final 数据类型 变量名;
变量名 = 变量值;
//
}
}
//final关键字修饰普通方法
class 类名 {
public final void 方法名() {
//
}
public final 数据类型 方法名() {
//
return 返回值;
}
}
//final关键字修饰类
final class 类名 {
}
//final关键字修饰对象引用
final 类名 对象名 = new 类名();
1.3.2、总结
- final关键字修饰成员变量：必须对成员变量赋值，赋值之后不能修改
- final关键字修饰局部变量：使用之前必须对局部变量进行赋值，赋值之后不能修改
- final关键字修饰普通方法：该成员方法不能被重写
- final关键字修饰类：该类不能被继承
- final关键字修饰对象引用：该对象赋值之后不能修改
1.4、接口【重点】
1.4.1、语法格式
//定义接口
interface 接口名 {
//属性
数据类型 常量名 = 常量值; //public、static和final省略
//抽象方法
void 方法名(); //public和abstract省略
数据类型 方法名();
//默认方法
public default void 方法名() {
//
}
public default 数据类型 方法名() {
//
return 返回值;
}
}
//实现接口
class 类名 implements 接口名1, 接口2, 接口3,... {
//
}
1.4.2、总结
- 接口中属性使用 static 和 final 关键字修饰，被称为常量
- 接口中的方法有抽象方法和默认方法，抽象方法没有方法体，默认方法有方法体。没有构造方法，不能被实例化
- 实现类必须要实现接口中所有抽象方法。一个实现类可以实现多个接口
- 接口可以继承接口，抽象类可以实现接口
day_12
1、面向对象_5【重点】
1.1、多态【重点】
1.1.1、方法中的多态
方法重写和方法重载就是方法中多态的体现形式
1.1.2、对象中的多态【重点】
多态：父类引用指向子类的对象
多态注意事项：必须有继承(extends)关系或实现(implements)关系、必须有方法重写。父类引用可以调用父类所有的成员方法和子类重写父类的方法，不能调用子类独有的方法
//语法格式
父类 父类引用名 = new 子类();
1.1.3、多态的转型
//语法格式
//向上转型
父类 父类引用名 = new 子类();
//例如
Father father = new Son();
//向下转型
父类 父类引用名 = new 子类();
子类 子类引用名 = (子类)父类引用名;
//例如
Father father = new Son();//向上转型
Son son = (Son)father;
1.1.4、开发中使用多态 - 向上转型
class Manager { //管理层类
// public void manage(Studnet student) {
// student.excute();
// }
// public void manage(Teacher teacher) {
// teacher.excute();
// }
public void manage(Person person) { //方法:管理
person.excute();
}
}
interface Person { //人类
void excute(); //方法:执行
}
class Studnet implements Person { //学生类
@Override
public void excute() {
//
}
}
class Teacher implements Person { //讲师类
@Override
public void excute() {
//
}
}
public class Demo_01 {
public static void mian(String[] args) {
Manager manager = new Manager();
manager.manage(new Studnet()); //多态
manager.manage(new Teacher());
}
}
1.1.5、关键字：instanceof
instanceof 关键字：比较操作符，返回值类型是布尔类型
目的用途：强转时不出问题
//语法格式
对象引用(对象名) instanceof 类名
//总结:左边的辈分小(对象引用) 右边辈分大(类)
1.1.6、开发中使用多态 - 向下转型
class Test {
public void tests(Object obj) {
if (obj instanceof String) {
String str = (String) obj;
System.out.println(str);
}
}
}
public class Demo_02 {
public static void mian(String[] args) {
Test test = new Test();
String str = new String("wxh");
test.tests(str); //多态
}
}
day_13
1、面向对象_6【重点】
1.1、关键字：static
1.1.1、语法格式
//static关键字修饰成员变量 - 静态属性
class 类名 {
static 数据类型 变量名;
}
//static关键字修饰成员方法 - 静态方法
class 类名 {
public static void 方法名() {
//方法体
}
public static 数据类型 方法名() {
//方法体
return 返回值;
}
}
//static关键字修改代码块 - 静态代码块
class 类名 {
static {
//语句体
}
}
main() {
//调用
类名.变量名 = 变量值;
System.out.println(类名.变量名);
类名.方法名();
}
1.1.2、static关键字的内存解析(静态属性为例)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PXHoc865-1659343917618)(images\static关键字的内存解析.png)]
1.1.3、总结
- 静态代码块：只要类加载，静态代码块就会执行
- 代码执行顺序：静态代码块、构造代码块、构造方法
2、异常【重点】
2.1、Throwable类【了解】
2.1.1、方法
| 方法名 | 返回值类型 | 说明 |
|---|---|---|
| getMessage()【常用】 | String | 返回详细消息字符串 |
| printStackTrace() | void | 打印标准错误流 |
| toString() | String | 返回错误的简短描述 |
2.2、异常 【重点】
2.2.1、语法格式
//try-catch
try {
//可能出现异常的代码块
} catch (Exception e) {
//异常的处理方式
}
//try-catch-finally
try {
//可能出现异常的代码块
} catch (Exception e) {
//异常的处理方式
} finally {
//无论是否发生异常，finally代码块中的代码总会被执行
}
2.3、异常的抛出(throw,throws)
2.3.1、基本概念
throws表示方法声明处抛出的异常，throw表示在代码块中抛出的异常（异常可以是自定义，也可以是java异常类）
public void test() throws Exception {
throw new Exception();
}
2.4、自定义异常
2.4.1、语法格式
class 自定义异常类 extends Exception {
//类体
}
2.4.2、应用实例
class SingleException extends Exception { //自定义异常
public SingleException() {
}
public SingleException(String message) {
super(message);
}
}
public class Demo_03 {
public static void main(String[] args) {
try {
isSingle(false);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
// throw 和 throws 的使用
public static void isSingle(boolean flag) throws Exception {
if (flag) {
throw new SingleException("xxx");
}
}
}
2.5、常见异常总结【面试题】
异常有编译时异常和运行时异常两种
2.5.1、常见编译时异常
- 类找不到异常：ClassNotFoundException
- 文件找不到异常：FileNotFoundException
- 输入输出流异常：IOException
- 数据库操作异常：SQLException
2.5.2、常见运行时异常
- 数组索引越界异常：ArrayIndexOutOfBoundsException
- 数组空指针异常：NullPointerException
- 类转换异常：ClassCastException
3、String类_1【重点】
3.1、String类的声明
3.1.1、语法格式
//第一种
String str = "xxx";
//第二种
String str = new String("xxx");
3.2、== 与 equals 的使用
3.2.1、应用实例
public class Demo_03 {
public static void main(String[] args) {
String str1 = "wxh";
String str2 = "wxh";
String str3 = new String("wxh");
String str4 = new String("wxh");
//注意🔺🔺🔺
System.out.println(str1 == str2);//true
System.out.println(str1 == str3);//false
System.out.println(str3 == str4);//false
System.out.println(str1.equals(str3));//true
}
}
3.2.2、内存解析
3.2.3、== 与 equals 的区别【面试题】
-
== 与 equals 的区别？
答：== 比较的是内存地址。equal比较的是内存地址，如果内存地址不一样，再去比较值
Day_14
1、String类_2【重点】
1.1、String类的方法
| 方法名 | 返回值类型 | 说明 |
|---|---|---|
| length() | int | 返回字符串的长度 |
| charAt(int index) | char | 获取指定位置字符 |
| equals(object obj) | boolean | 判断两个字符串是否相等 |
| equalsIgnoreCase(object obj) | boolean | 忽略大小写，判断两个字符串是否相等 |
| isEmpty() | boolean | 判断字符串是否为空 |
| endsWith(String str) | boolean | 判断字符串是否以指定字符串结尾 |
| contains(String str) | boolean | 判断字符串是否存在指定字符串 |
| indexOf(char ch) | int | 获取首次出现指定字符的位置 |
| indexOf(String str) | int | 获取首次出现指定字符串的位置 |
| lastIndexOf(char ch) | int | 获取最后一次出现指定字符的位置 |
| lastIndexOf(String str) | int | 获取最后一次出现指定字符串的位置 |
| replace(char oldChar, char newChar) | String | 将原字符替换指定字符 |
| replace(String oldStr, String newStr) | String | 将原字符串替换指定字符串 |
| subString(int beginIndex) | String | 截取字符串 |
| subString(int beginIndex, int endIndex) | String | 截取字符串 |
| split(String str) | String[] | 以str分隔作为分割符，将字符串转化为字符串数组 |
| toUpperCase() | String | 将小写字母转换为大写字母 |
| toLowerCase() | String | 将大写字母转换为小写字母 |
| trim() | String | 去除首尾空格 |
1.2、字符数组和字符串相互转换
1.2.1、字符数组转为字符串
public class CharsToString {
public static void main(String[] args) {
char[] chs = {'w','x','h','w','x','h'};
//方法一
String str1 = new String(chs);
System.out.println(str1);
//方法二【重点】
String str2 = String.valueOf(chs);//valueOf()是静态方法
System.out.println(str2);
}
}
1.2.2、将字符串转为字符数组
public class StringToChars {
public static void main(String[] args) {
//方法一【重点】
String str = "wxhwxhwxh";
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.print(chars[i] + " ");
}
//方法二
String str2 = "w-x-h-w-x-h-w-x-h";
String[] strs = str2.split("-");//字符串数组
for (int i = 0; i < strs.length; i++) {
System.out.print(strs[i] + " ");
}
//方法三
StringBuffer stringBuffer = new StringBuffer("wxhwxhwxh");
char[] chars2 = new char[stringBuffer.length()];
stringBuffer.getChars(0,stringBuffer.length(),chars2,0);
for (int i = 0; i < chars2.length; i++) {
System.out.print(chars2[i] + " ");
}
//方法四
StringBuilder stringBuilder = new StringBuilder("wxhwxhwxh");
char[] chars3 = new char[stringBuilder.length()];
stringBuilder.getChars(0,stringBuilder.length(),chars3,0);
for (int i = 0; i < chars3.length; i++) {
System.out.print(chars3[i] + " ");
}
}
}
2、String Buffer类和StringBuilder类【重点】
2.1、String Buffer类和StringBuilder类的方法
| 方法名 | 返回值类型 | 说明 |
|---|---|---|
| length() | void | 返回字符串的长度 |
| charAt(int index) | char | 获取指定位置字符 |
| indexOf(String str) | int | 获取首次出现指定字符的位置 |
| lastIndexOf(String str) | int | 获取最后一次出现指定字符的位置 |
| subString(int start) | String | 截取字符串 |
| subString(int start, int end) | String | 截取字符串 |
| append(String str) | StringBuffer | 追加字符串 |
| insert(int index, String str) | StringBuffer | 指定位置添加元素 |
| deleteCharAt(int index) | StringBuffer | 删除指定位置元素 |
| delete(int start, int end) | StringBuffer | 删除指定区间位置元素 |
| replace(int start, int end, String str) | StringBuffer | 将原字符串替换指定字符串 |
| reverse() | StringBuffer | 字符串反转 |
| getChars(int begin, int end, char[] chars, int begin) | void | 将指定区间字符串复制到字符数组中 |
| setCharAt(int index,char ch) | void | 设置指定位置指定字符 |
| setLength() | void | 设置字符串长度 |
| toString | void | 返回字符串 |
2.2、String类、StringBuffer类、StringBuilder类三者区别【面试题】
-
String类，StringBuffer类，StringBuilder类区别？
String类 StringBuffer类 StringBuilder类 字符串常量，不可变，字符串拼接时是两个不同的空间 字符串变量，可变，线程安全，字符串拼接时是字符串追加 字符串变量，可变，线程不安全，字符串拼接时是字符串追加 执行效率：StringBuilder，StringBuffer，String
扫一扫
3635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
