Java基础（2）面向对象

最新推荐文章于 2024-11-03 11:01:20 发布

xiuxiuhh

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量42

点赞数

文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/xiuxiuhh/article/details/132388751

版权

1 Java方法

Java方法是程序中最小的执行单元，先定义后调用
无参方法

    public static void main(String[] args) {
        //    方法的调用
        min();
    }
    public static void min() {
        int n1=10;
        int n2=20;
//        三目运算符
        System.out.println(n1<n2?n1:n2);

有参方法：定义时，多个参数之间使用逗号(，)分隔；方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

    public static void main(String[] args) {
        getMax(10,20);
        max();
    }
//    有参方法
    public static void getMax(int a ,int b) {
        if (a>b){
            System.out.println("较大值为："+a);
        }else {
            System.out.println("较大值为："+b);
        }
    }

形参：方法定义中的参数；等同于变量定义格式，例如：int number
实参：方法调用中的参数；等同于使用变量或常量，例如： 10 number

有返回值方法

    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int result = getMax(10,20);
        System.out.println(result);
        //在main()方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(10,20));
    }
    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
        return a>b?a:b;
    }

方法的注意事项
1、方法不能嵌套定义
2、void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

方法重载
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
1、多个方法在同一个类中；
2、多个方法具有相同的方法名
3、多个方法的参数不相同，类型不同或者数量不同
注意：
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

2 类和对象

2.1 类的定义

类的组成是由属性和行为两部分组成：

属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员方法来体现（和普通方法定义相比去掉static关键字即可）

类的定义步骤：
1、定义类
2、编写类的成员变量
3、编写类的成员方法

2.2 对象的使用

创建对象的格式：类名对象名 = new 类名();
调用成员的格式：
对象名.成员变量
对象名.成员方法();

2.3 封装

private关键字：是一个修饰符，可以用来修饰成员（成员变量，成员方法）
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

class Student {
    //成员变量
    private String name;
    private int age;
    //get/set方法
    public void setName(String n) {
        name = n;
    }
    public String getName() {
        return name;
    }
    public void setAge(int a) {
        age = a;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*学生测试类*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
        s.show();
        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());
    }
}

this关键字：修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void show() {
        System.out.println(name);
    }
}

2.4 继承

好处：

1.提高了代码的复用性
2.提高了代码的可维护性
3.让类与类之间产生关系, 是多态的前提.

弊端：让类与类之间产生了关系, 也就让类的耦合性增强了

开发原则：高内聚，低耦合
内聚：指的是类自己独立完成某些事情的能力
耦合：指的是类与类之间的关系

方法的重写：子类中出现和父类一模一样的方法时，称为方法重写。方法重写要求返回值的数据类型也必须一样
注意实现

1.子类重写父类方法时，方法声明上要用@Override注解来修饰。
2.父类中私有的方法不能被重写。
3.子类重写父类方法时，访问权限不能更低。

2.5 多态

好处：提高了程序的扩展性

弊端：父类引用不能访问子类的特有功能
问：那如何解决这个问题呢? 通过向下转型来解决这个问题

向上转型:
格式：父类型对象名 = new 子类型();
例如: Animal an = new Cat();
向下转型:
格式：子类型对象名 = (子类型)父类引用;
例如: Cat c = (Cat)an;

// 向下转型
Animal animal3 = new Cat();
Cat cat = (Cat) animal3; // 向下转型
Dog dog = (Dog) animal3; // 直接报错(ClassCastException 类型转换异常), 因为本身就不是 Dog类型, 所以无法进行向下转型

cat.seize();
System.out.println(animal3);

说明: 向下转型的目的是为了调用子类中特有的方法

2.6 API接口

API全称是Application Programming Interface(应用程序编程接口)，本意指的是JDK提供的各种功能的Java类和接口，但是我们常说的”打开API”并不是指打开这些Java类和接口，而是打开API帮助文档。

API 帮助文档就相当于说明书,是用来介绍JDK提供的各个类和接口的功能的，从而帮助我们快速上手使用。
在这里插入图片描述
看类在哪个包下. 如果是java.lang包下的类, 则无需导包, 可以直接使用. 而其他包下的类和接口, 在使用前必须先导包。如 Rondom就是在java.util下的包, 所以必须先导包。
常用的API
Object类
Java顶级父类是：Object。
Object类是所有类的父类，所有的类都直接或者间接继承自Object类。

构造方法

public Object() //Object类中只有一个空参构造.

成员方法

public String toString()：返回对象的字符串表示形式(即：地址值)，无意义，建议子类重写该方法。
public boolean equals(Object obj)：比较两个对象是否相等，默认比较的是地址值，无意义，子类一般都会重写该方法。
注意：实际开发中，我们认为如果同一个类的两个对象，各个属性值都相同，那么它们就是同一个对象。

String类
String代表字符串类，即：由多个字符组成的一串数据。字符串的本质就是一个字符数组
常见API：

public boolean equals(Object obj) 比较两个字符串的内容是否相同，区分大小写
public boolean equalsIgnoreCase(String s) 比较两个字符串的内容是否相同，不区分大小写
public int length() 获取字符串的长度
public char charAt(int index) 根据索引, 获取该索引对应的字符。

包装类
为了对基本类型进行更多更方便的操作，Java中每个基本类型都有对应引用类型，这就是包装类，支持赋NULL值
写法：把基础数据类型的首字母大写，有两个特别的，int、char

基本类型	对应的包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

以Interger演示相关的操作：

构造方法：
public Integer(int value)：把int类型的数据封装成其对应的Integer对象
public Integer(String s)：把字符串类型的整数封装成其对应的Integer对象(纯数字字符串)
int --> string:
方式一：直接拼接一个空字符串
方式二：valueof
string --> int:
方式一: string --> integer --> int
new Integer(“11”).intValue()
方式二: 通过parseInt() 静态方法来实现
自动拆箱和装箱：
拆箱：包装类 --> 基本类型
装箱：基于类型 --> 包装类型
例如：
Integer i = 100; 装箱
int j = i; 拆箱

作用：

1、包装类的兼容性更强，支持接收null
2、在使用的基本数据类型的时候，建议优先使用包装类型
3、将字符串转换为基本数据类型的时候，一般都是通过包装类处理 (提供对应特定方法 XXX包装类.parseXXX(“字符串”))

2.7 异常的处理方法

在这里插入图片描述
处理异常方式：
1、自己处理: try.catch.finally
特点: 处理完后, 程序会继续向下执行.
格式：

try{
//业务实现的代码
} catch(Exception e) {
e.printStackTrace()
} finally{
//回收资源，这里总会被执行。
}

2、抛出异常
特点: 处理完后, 程序会终止执行。
格式：throws 异常的类型; //该内容是写到方法的形参列表之前的.

public static void main(String[] args) throws Exception {
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        // 编译期异常解决方案: 思考 我是否会出现这个异常呢? 如果不会 直接选择抛出或者 程序有最终异常处理方案 直接抛出
        Date date = format1.parse("2022/05/03 12:14:20");
        System.out.println(date);
    }

3 Lambda表达式

它是一个编写方法的语法糖。可以节省代码，看起来更简洁。
Lambda表达式本身就是匿名方法（代码块），就是将方法（代码块）赋值给一个变量，lambda的类型都是一个接口。
格式：(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开, 如果没有参数，留空即可
->：由英文中画线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
组成Lambda表达式的三要素：形式参数，箭头，代码块
使用的前提条件：有一个接口，且接口中有且仅有一个抽象方法。

Lambda省略模式
规则:

参数类型可以省略。但是有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

//方式三
        demo.useAddable((int x,int y) -> x + y);
              
//方式三
        demo.useFlyable(s -> System.out.println(s + "lambda表达式的fly方法..."));
        
//方式三按
        demo.useEatable(() -> System.out.println("采用Lambda表达式来实现Eatable的eat方法"));

Lambda表达式和匿名内部类的区别

所需类型不同：
匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
Lambda表达式：只能是接口
使用限制不同：
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类，只适用于函数式接口。
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同：
匿名内部类：编译之后，产生一个单独的.class字节码文件
Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成。

4 JDBC协议

JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API。JDBC是Java访问数据库的标准规范，可以为不同的关系型数据库提供统一访问，它由一组用Java语言编写的接口和类组成。
JDBC需要连接驱动，驱动是两个设备要进行通信，满足一定通信数据格式，数据格式由设备提供商规定，设备提供商为设备提供驱动软件，通过软件可以与该设备进行通信。
JDBC规范（掌握四个核心对象）：

1、DriverManager:用于注册驱动
2、Connection: 表示与数据库创建的连接
3、Statement: 操作数据库sql语句的对象
4、ResultSet: 结果集或一张虚拟表

错误记录：
1、Column count doesn't match value count at row 1前后列数不等造成的
如：insert into user(colm1,colm2,colm3) value(?,?,?,?)，将前后一一对应上就可以了
2、No suitable driver found for jdbc:mysql://localhost:3306/db_jdbctest jdbc驱动没加载
解决方法：

1.将 JAR 文件直接拷贝到项目的类路径下，比如 lib 文件夹。（右键jar驱动包添加为库，添加为模块库）
2.如果你使用构建工具如 Maven 或 Gradle，你可以在对应的配置文件中添加依赖，然后重新构建项目。加jdbc驱动后加载到库里重新运行就可以了

JDBC查询返回多条数据：

public class Demo03_SelectDemo {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement ps=null;
        ResultSet rs=null;
        List<User> list=new ArrayList<User>();
        try {
            conn=DBUtils.getConn();
            String sql="select * from `user`";
            ps=conn.prepareStatement(sql);
            boolean flag=ps.execute();
            System.out.println(flag);
            rs=ps.executeQuery();

//            4.遍历数据获取结果
//            rs.next():如果有数据返回true;
            while (rs.next()){
                User user=new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setSex(rs.getString("sex"));
                user.setAge(rs.getInt("age"));
                user.setAddress(rs.getString("address"));
                list.add(user);
                System.out.println();
            }
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            //        5.关闭连接
            try {
                ps.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        for (int i=0;i<list.size();i++){
            User user=list.get(0);
            System.out.println(user);
        }
        /**
         * 增强型for循环 iter+Enter（快捷键）
         * for(数据类型 变量名：集合类型/数组类型){
         *
         */
        System.out.println("------------方法二-------------");
        for (User user:list){
            System.out.println(user);
        }
        System.out.println("------------方法三-------------");
//        1.获取迭代器
        Iterator<User> iterator=list.iterator();
//        2.迭代
        while (iterator.hasNext()){
            User user=iterator.next();
            System.out.println(user);
        }
    }
}

在这里插入图片描述

5 Maven的仓库

作用：

1、maven对项目的第三方构建(jar包)进行统一管理。向工程中加入jar包不要手工从其他地方拷贝, 通过maven定义jar包的坐标,自动从maven仓库中下载到工程中。（等价于Python中的pip）
2、 maven提供一套对项目生命周期管理的标准, 开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理: 编译、测试、打包、部署、运行。（把Java打成jar包）
3、maven对工程分模块构建,提高开发效率

仓库名称	作用
本地仓库	相当于缓存, 工程会从远程仓库(互联网)去下载jar包,将jar包存在本地仓库(在程序员的电脑上)。第二次不需要从远程仓库去下载。先从本地仓库找,如果找不到才会去远程仓库找
中央仓库	就是远程仓库, 仓库中jar由专业团队(maven团队)唯一维护。中央仓库的地址: https://mvnrepository.com/ ；下载地址：https://archive.apache.org/dist/maven
远程仓库	在公司内部假设一台私服, 其他公司假设一台仓库, 对外公开

Maven的坐标
Maven的一个核心的作用就是管理项目的依赖, 引入我们所需的各种jar包等。为了能自动化的解析任何一个java构件,maven必须将这些jar包或者其他资源进行唯一标识, 这是管理项目的依赖的基础, 也就是我们要说的坐标。包括我们自己开发的项目,也是要通过坐标进行唯一标识的, 这样才能在其他项目中进行依赖引用。坐标的定义元素如下: