面向对象, 常用类, 集合, 异常, JDBC, mysql数据库 复习

  继承

子承父类，父类通用，子类更具体

继承代码实现

 1 /**
 2  * 1. 将类中重复的部分提取成为父类
 3  */
 4 public class Animal {
 5     private String name;
 6     private String food;
 7 
 8     public Animal(String name, String food) {
 9         this.name = name;
10         this.food = food;
11     }
12 
13     public void eat() {
14         System.out.println(name + "正在吃" + food);
15     }
16 }
17 
18 /**
19  * 2. 子类继承父类，对父类进行扩展
20  */
21 public class Cat extends Animal {
22 
23     public Cat(String name, String food) {
24         super(name, food);
25     }
26 }
27 public class Dog extends Animal{
28 
29     public Dog(String name, String food) {
30         super(name, food);
31     }
32 }
33 
34 /**
35  * 3. 测试
36  */
37 public class TestExtends{
38     public static void main(String[] args) {
39         Animal cat = new Cat("三三", "鱼");
40         cat.eat();
41         Animal dog = new Dog("二哈", "香肠");
42         cat.eat();
43     }
44 }

 多态

1、核心：提高代码的的维护性和可扩展性

2、实现多态的三个必要条件：继承、重写、父类引用指向子类对象（向上转型）

3、多态的实现方法：重写、接口、抽象类和抽象方法

多态代码实现

 1 /**
 2  * 1. 创建动物类，定义动物吃什么的方法
 3  */
 4 class Animals {
 5     private String name;
 6     private String food;
 7     
 8     public Animals(String name, String food) {
 9         super();
10         this.name = name;
11         this.food = food;
12     }
13 
14     public void eat() {
15         System.out.println(this.name + "会吃" + this.food);
16     }
17 }
18 
20 /**
21  * 2. 创建Cat类来实现吃的功能
22  */
23 class Cat extends Animals{
24     public Cat(String name, String food) {
25         super(name, food);
26     }
27 
28     @Override
29     public void eat() {
30         super.eat();
31     }
32 }
33 
35 /**
36  * 3. 通过向上转型和向下转型实现多态
37  */
38 public class Test01 {
39     public static void main(String[] args) {
40         // 向下转型
41         Animals animals = new Cat("三三", "鱼");
42         animals.eat();
43         // 向上转型
44         Cat cat = (Cat) animals;
45         cat.eat();
46     }
47 }

（7）抽象类

核心思想：让代码有更强的可扩展性

特点

抽象类不能实例化对象。
如果一个类包含抽象方法，那么该类必须是抽象类
任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类
抽象类中的抽象方法只有方法声明，没有方法体
构造方法和static修饰的方法不能声明为抽象方法
代码实现
 1 /**
 2  * 1. 创建员工抽象类
 3  */
 4 abstract class Employees {
 5     // 成员变量
 6     private String name;
 7     private String address;
 8     private Integer number;
 9 
10     // 构造方法
11     public Employees(String name, String address, Integer number) {
12         System.out.println("Employees.Employees()");
13         this.name = name;
14         this.address = address;
15         this.number = number;
16     }
17 
18     // 定义信息抽象函数
19     public abstract void call();
20    
21     // 省略getter 和 setter方法
22     ......
23     }
24 }
25 
26 class Salary extends Employees {
27     private Double salary;
28 
29     public Salary(String name, String address, Integer number, Double salary) {
30         super(name, address, number);
31         this.salary = salary;
32         System.out.println("Salary.Salary()");
33     }
34 
35     // 2. 重写父类的抽象方法
36     @Override
37     public void call() {
38         System.out.println(super.getNumber() + "是" + super.getName() + "的电话，他住在" + 
39         super.getAddress() + "他现在的工资是" + this.salary);
40     }
41 }
42 
43 public class Test {
44     public static void main(String[] args) {
45         // 3. 抽象类的对象必须由子类去实例化
46         Employees emp = new Salary("孙悟空", "花果山", 1234, 222.66);
47         emp.call();
48     }
49 }

（8）接口

特点：

接口不能实例化对象，没有构造方法
接口中的方法只能是抽象方法，默认使用public abstract修饰
接口中的变量只能是常量，默认使用public static final修饰
接口支持多继承，但接口不是被继承了，而是被实现了
接口和抽象类的区别

接口中的方法只能是抽象方法，而抽象类中的方法可以是普通方法，构造方法和抽象方法
接口中的变量只能是常量，而抽象类中的方法可以是任意类型
接口中不能含有静态代码块和静态方法，而抽象类中可以有
一个类可以实现多个接口，但一个类只能继承一个抽象类
 1 /**
 2  * 1. 创建Animal接口
 3  */
 4 interface Animal {
 5     // 定义睡觉抽象方法
 6     void sleep();
 7 
 8     // 定义吃饭抽象方法
 9     void eat();
10 }
11 
12 /**
13  * 2. 创建Dog接口继承Animal接口
14  */
15 interface Dog extends Animal {
16     // 定义游泳抽象方法
17     void swim();
18 }
19 
20 /**
21  * 3. 创建HaShiQi接口继承Dog和Animal接口，实现多继承
22  */
23 interface HaShiQi extends Dog, Animal {
24     // 定义拆家抽象方法
25     void demolishedFamily();
26 }
27 
28 /**
29  * 4. 创建测试类来实现接口，并且复写所有抽象方法
30  */
31 public class TestAnimal implements HaShiQi {
32 
33     @Override
34     public void swim() {
35         System.out.println("哈士奇会游泳");
36     }
37 
38     @Override
39     public void sleep() {
40         System.out.println("哈士奇会睡觉");
41     }
42 
43     @Override
44     public void eat() {
45         System.out.println("哈士奇喜欢吃苦瓜");
46     }
47 
48     @Override
49     public void demolishedFamily() {
50         System.out.println("哈士奇会拆家");
51     }
52 
53     public static void main(String[] args) {
54         // 使用多态实例化对象
55         HaShiQi dog = new TestAnimal();
56         dog.eat();
57         dog.sleep();
58         dog.demolishedFamily();
59         dog.swim();
60     }
61 }

2.常用类（API）
                        
 

1、Java API

是对Java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。

2、Object类

根基类，每个类都使用Object作为超类（父类），所以对象都继承实现了这个类的方法

equals方法，在Object中默认使用==比较，比较的是对象地址，然而在其他类中，对equals方法进行了重写，调用这个方法  x.equals(y) 判断x和y的内容是否相等，而不是比较地址

3、Arrays类

是操作数组工具类，里面定义了常见数组的静态方法

在文章上面有一个Arrays类的代码展示，可以进行翻阅查看，这里就不再重复书写😂😂😂😂

4、基本数据类型分装类

自动装箱：基本类型自动转换为包装类型

自动拆箱：包装类型自动转换为基本类型

5、String类

● 构造方法
public String()
public String(String str)
public String(byte[] bytes)
public String(char[] value)
 
 
● 判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()
boolean startsWith(String prefix)
boolean endsWith(String suffix)
 
 
●获取功能
int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
 
 
 
● 转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符)
 
 
● 替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
● 去除字符串两空格
String trim()
 

6、StringBuffer类和StringBuilder类 

● 添加功能
public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)
● 删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
● 替换功能
public StringBuffer replace(int start,int end,String str)
● 反转功能
public StringBuffer reverse()
● 截取功能
public String substring(int start)
public String substring(int start,int end)
● 截取功能和前面几个功能的不同
返回值类型是String类型，本身没有发生改变
● StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程
安全的

三者的区别：

String：是字符常量,适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer ：适用多线程下在字符缓冲区进行大量操作的情况

7、Math类

数学类，常用的数学方法

package com.ffyc.javaapl.Mathdemo;
 
public class Math1 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-1));//Math.abs()求求绝对值
        System.out.println(Math.sqrt(9.0));//Math.sqrt()开方
        System.out.println(Math.max(5,2));//求最大值
        System.out.println(Math.floor(9.9));//向下取整9.0
        System.out.println(Math.ceil(9.1));//向下取整10.0
        System.out.println(Math.round(9.1));//9
        System.out.println(Math.round(9.5));//Math.round()四舍五入取整 10
        System.out.println(Math.random());//在0-1之间随机数，0<=random<1
        System.out.println(Math.pow(2,3));//pow(double a, double b) a^b 8 幂次方
    }
}

 8、Random类

产生随机数

代码实现

import java.util.Random;
 
public class Random1 {
    public static void main(String[] args) {
        Random random=new Random();
        System.out.println(random.nextBoolean());//随机产生一个boolean值
        System.out.println(random.nextInt());//在int型范围内产生一个随机值
        System.out.println(random.nextInt(3));//在0-2内产生一个随机值
    }
}

 9、Date类/Calender类/SimpleDateFormat类

Date类代表当前系统时间

Date类代码实现

import java.util.Date;
 
public class Datedemo1 {
    public static void main(String[] args) {
        Date date=new Date();//创建一个date对象，程序运行是会将当前时刻存入
        System.out.println(date);
        System.out.println(date.getYear()+1900);//return normalize().getYear() - 1900;
        System.out.println(date.getMonth()+1);// return normalize().getMonth() - 1
        System.out.println(date.getDate());//
        System.out.println(date.getTime());//时间戳，自1970 1.1 0：0：0到程序运行时刻的毫秒值 1708844950270
        Date date2=new Date(1708844950270L);
        System.out.println(date2);//new Date(long date),传入一个毫秒值，返回一个时刻
    }
}
Calender类是一个抽象类，在实际使用时实现特定的子类对象。创建对象过程对程序员来说是透明的，只需要使用getInstance方法创建

 Calender类代码实现

import java.util.Calendar;
 
public class Calenderdemo1 {
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();//getInstance子类
       // System.out.println(calendar);
 
        System.out.println(calendar.get(Calendar.YEAR));//获取年份
        System.out.println(calendar.get(Calendar.MONTH)+1);//获取月份
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
 
 
    }
}

 SimpDateFormat类

日期格式化类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
 
public class SimpleDateFormdemo1 {
    public static void main(String[] args) throws ParseException {
        //把字符串日期转换为date对象
        String s="2024-2-29 12:12:12 星期三";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-mm-dd HH:mm:ss E");
        Date date=sdf.parse(s);
        System.out.println(date);
      //  把date对象转换为字符串日期
        Date date1=new Date();
        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String s1=sdf1.format(date1);
        System.out.println(s1);
 
 
    }
}

10、BigInteger类/BigDecimal类

BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意 精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而 不会丢失任何信息

import java.math.BigDecimal;
import java.math.BigInteger;
 
public class BigIntergedemo1 {
    public static void main(String[] args) {
        BigInteger a1=new BigInteger("11111111111111111111111111111111");
        BigInteger a2=new BigInteger("99999999999999999999999999999999");
        BigInteger a3=a1.add(a2);
        BigInteger a4=a1.multiply(a2);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
    }
}
 BigDecimal类

比double 和folat精确度要高得多

import java.math.BigDecimal;
import java.math.RoundingMode;
 
public class BigDecimaldemo1 {
    public static void main(String[] args) {
        BigDecimal a1=new BigDecimal("0.3");
        BigDecimal a2=new BigDecimal("0.1");
        System.out.println(a1.add(a2));
        BigDecimal a3=new BigDecimal("10");
        BigDecimal a4=new BigDecimal("3");
        System.out.println(a3.divide(a4,2, RoundingMode.HALF_UP));//a3/a4，a4是除数，scale是保留小数的位数，RoundingMode是舍入模式
 
    }
}

3.集合

1.分类及功能

2.Collectiong接口常用的方法

4.IO

一、简介

流的概念：流是有起点和终点的一组有顺序的字节集合，作用是进行数据传输

流的分类

按照数据流向不同可以分为输入输出流；
按照处理数据单位不同可以分为字节流和字符流
输入流和输出流的作用

输入流：程序从数据源读取数据
输出流：将数据从程序中写入指定文件
字节流和字符流的作用

字节流：以字节为单位处理所有类型数据
字符流：以字符为单位处理纯文本文件

二、体系结构

三.IO常用方法

try{

可能会发生异常的代码

}catch(异常类型 引用名){

异常处理代码

}finally{

必须执行代码

}

● try

检测不安全的代码块（发现异常）

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将

跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代

码放到try块中，因为随时可能会中断执行。

catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类

的顺序写，否则有编译错误

finally

finally该内容总是会执行的，只能有一个finally语句

finally{

必须执行的逻辑

}

5.自定义异常

● 自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的

子类

● 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

}

}

● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或

throws抛出

自定义异常示例：

6.JDBC