面向对象编程-Java

已于 2024-03-05 16:58:34 修改
阅读量631 收藏 20
点赞数 12
文章标签： java python 开发语言
于 2024-03-05 16:55:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46062641/article/details/136483604
版权

面向对象编程

面向对象 & 面向过程

面向过程思想（线性思维）

  • 步骤清晰简单，第一步做什么，第二步做什么……
  • 面向过程适合处理一些较为简单的问题

面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

队医描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微规操作，仍需要面向过程的思路去处理。

什么叫面向对象

  • 面向对象编程（Object-Oriented Programming，OOP）
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据
  • 抽象
  • 三大特性
    • 封装
    • 继承
    • 多态
  • 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板

方法

  • 方法的定义
    • 修饰符
    • 返回类型
    • break：跳出switch，结束循环 和 return 的区别
    • 方法名：注意规范就OK 见名知意
    • 参数列表：（参数类型，参数名） …：可变长参数
    • 异常抛出：后面学习
package com.oop.demo01;

import java.io.IOException;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:32
 */
//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型   方法名（...）{
        方法体
        return 返回值;
    }
     */
    // return 结束方法，返回一个结果！
    public String sayHello(){
        return "Hello,world";
    }
    public void hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b; //三元运算符
    }
    // 数组下标越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{

    }
}

  • 方法的调用：递归

    • 静态方法

    • 非静态方法

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:45
 */
//学生类
public class Student {
    //方法
    public void say(){
        System.out.println("学生说话了");
    }
}

package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:45
 */
public class Demo02 {
    public static void main(String[] args) {
        // 静态方法 static
        // Student.say();
        // 非静态方法
        // 实例化这个类
        // 对象类型 对象名 = 对象值;
        Student student = new Student();

        student.say();
    }
    /*
    两个都不是静态方法，或者两个都是静态方法，则可以直接相互调用
    若静态方法调用非静态方法则会出错
    静态方法是和类一起加载的
    普通方法是类实例化之后才存在
     */
    public void a(){

    }
    public void b(){

    }
}

    • 形参和实参

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 1:56
 */
public class Demo03 {
    public static void main(String[] args) {
        // 调用方法的两种形式
        // 实际参数和形式参数的类型要对应
        int add = new Demo03().add(1,2);
        /*
        加上static修饰符
        int add = Demo03.add(1,2);
         */
        System.out.println();
    }
    public int add(int a,int b){
        return a+b;
    }
}

    • 值传递和引用传递

    • package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:29
 */
// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo04.change(a);
        System.out.println(a);
    }
    // 返回值为空
    public static void change(int a){
        a = 10;
    }
}


package com.oop.demo01;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:33
 */
// 引用传递：对象，本质还是值传递
    // 对象，内存
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);    //null
        change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        // person是一个对象：指向的 ---> Person person = new Person(); 这是一个具体的人，可以改变属性！
        person.name = "caobo";
    }
}
// 一个文件里面只能有一个public class，但是可以有多个class
// 定义了一个Person类，有一个属性：name
class Person{
    String name;    //null
}

    • this关键字

类与对象的关系

  • 类是一种抽象的数据类型，他是对某一类十五整体描述/定义，但是并不能代表某一个具体的事物。

    • 动物，植物，手机，电脑…
    • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体事物应该具备的特点和行为

  • 对象是抽象概念的具体实例

    • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
    • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建与初始化一个对象

  • 使用new关键字创建对象
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化以及对类中构造器的调用
package com.oop.demo02;

import java.sql.SQLOutput;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:51
 */
// 学生类
public class Student {
    // 属性：字段
    String name;    // null
    int age;    // 0

    // 方法
    public void study(){
        // this代表当前这个类
        System.out.println(this.name+"在学习");
    }
}

/*
Person ---> 身高，体重，国籍...
学程序好？对世界进行更好的建模！音乐，旅游

package com.oop.demo02;

import com.oop.demo02.Student;


// 一个项目应该只存在一个main方法
    public static void main(String[] args) {
        // 类是抽象的，需要被实例化
        // 类实例化后会返回一个自己的对象
        // student对象就是Student类的一个具体实例
        Student xiaoming = new Student();
        Student xh = new Student();
        xiaoming.name="小明";
        xiaoming.age=3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name="小红";
        xh.age=3;
        System.out.println(xh.name);
        System.out.println(xh.age);
    }

 */
  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    • 1.必须和类的名字相同
    • 2.必须没有返回值类型，也不能写void
package com.oop.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 3:09
 */
// java----> class
public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    // 显示的定义构造器
    String name;
    // 实例化初始值
    // 1.使用new关键字，本质是在构造器
    // 2.用来初始化值
    public Person(){
        this.name="caobo";
    }
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;   // this.name代表对象本身的name，name是传递进来的name
    }
    // alt + insert快捷键，自动生成构造器
}
/*
public static void main(String[] args) {
        // new 实例化了一个对象
        Person person = new Person();
        Person person2 = new Person("狂神");

        System.out.println(person.name); //caobo
        System.out.println(person2.name); //狂神
    }
    构造器：
        1. 和类名相同
        2. 没有返回值
    作用：
        1. new 本质在调用构造方法
        2. 初始化对象的值
    注意点：
        1. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
    Alt + Insert
    this. = 
 */


package com.oop.Demo03;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-04 2:56
 */
public class Pet {
    public String name;
    public int age;
    // 无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}


package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo02.Student;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="丑橘";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
        Pet cat = new Pet();
    }
}

在这里插入图片描述

小结

  1. 类与对象
    1. 类是一个模板：抽象，对象是一个具体的实例
  2. 方法
    1. 定义，调用
  3. 对象的引用
    1. 引用类型：基本类型（8），对象是通过引用来操作的：栈—>堆
  4. 属性：字段Field 成员变量
    1. 默认初始化：
      1. 数字：0 0.0
      2. char：u0000
      3. boolean：false
      4. 引用：null
    2. 修饰符 属性类型 属性名 = 属性值；
  5. 对象的创建和使用
    1. 必须使用new关键字创建对象，构造器 Person caobo = new Person();
    2. 对象的属性 caobo.name
    3. 对象的方法 caobo.sleep()
  6. 类：
    1. 静态的属性 属性
    2. 动态的行为 方法

封装、继承、多态。

封装

该露的露，该藏的藏

我们设计程序要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

记住这句话就够了：属性私有，get/set

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统的可维护性增加了
package com.oop.demo04;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-04 23:38
 */
// 类    private：私有
public class Student {
    // 属性私有
    private String name;// 名字
    private int id;// 学号
    private char sex;// 性别
    private int age;
    // 学习（）

    // 睡觉（）
    // 提供一些可以操作这个属性的方法
    // 提供一些public的get、set方法
    // get 获取这个数据
    public String getName(){
        return this.name;
    }
    // set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0) {    //不合法
            age=3;
        }else{
            this.age = age;
        }
    }
}



package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo04.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        String name = s1.getName();
        s1.setName("caobo");
        System.out.println(s1.getName());
        s1.setAge(-1); // 不合法的
        System.out.println(s1.getAge());
    }
    // alt + insert   自动生成get、set方法
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思的“扩展”。子类是父类的扩展

JAVA中类只有单继承，没有多继承

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
  • 子类和父类之间，从意义上讲应该具有“is a”的关系
  • final修饰的类不能被继承，就没有子类了
package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// Person 人:父类
    //在Java中，所有的类都默认继承Object类
    // public
    // protected
    // default
    // private 私有的是无法继承的
public class Person/* extends Object*/ {
    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say(){
        System.out.println("说了一句话");
    }
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// 学生  is 人：派生类，子类
    // 子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    // ctrl + h     继承树
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:38
 */
// Teacher is 人：派生类，子类
public class Teacher extends Person{
}

package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        Person person = new Person();

    }
    // alt + insert   自动生成get、set方法
}

object类

super this

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或构造方法中！
3.super和this不能同时调用构造方法！

Vs this：
1.代表的对象不同：
this:本身调用者这个对象
super：代表父类对象的引用
2.前提：
this：没有继承也可以使用
super：只能在继承条件下才可以使用
3.构造方法：
this()：本类的构造
super()：父类的构造

package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("秦将");
        //student.test1();

    }
    // alt + insert   自动生成get、set方法
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// 学生  is 人：派生类，子类
    // 子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    // 隐藏代码 ：调用了父类的无参构造

    public Student() {
        // 默认调用父类的无参
        //super();    // 调用父类的构造器，必须在子类构造器的第一行
        this("hello"); // 调用子类的构造器，同样必须在子类构造器的第一行
        System.out.println("Student的无参构造执行了");
    }

    public Student(String name) {
        this.name = name;
    }

    // ctrl + h     继承树
    private String name = "caobo";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();        // Student
        this.print();   // Student
        super.print();  // Person

    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);


    }
}

package com.oop.demo05;

import javax.lang.model.element.NestingKind;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 0:37
 */
// Person 人:父类
    //在Java中，所有的类都默认继承Object类
    // public
    // protected
    // default
    // private 私有的是无法继承的
public class Person/* extends Object*/ {

    public Person(String name) {
        System.out.println("无参执行了");
    }

    protected String name="曹博";
    public void print(){
        System.out.println("Person");
    }
}

方法重写

重写：需要有继承关系，子类重写父类的方法!

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大但不能缩小：public>protected>default>private
  4. 抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException–>Exception(大)

重写，子类的方法和父类必须要一致；方法体不同；

为什么需要重写：

1.父类的功能子类不一定需要，或者不一定满足！
Alt + Insert：override

package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 1:51
 */
// 重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>test");
    }
}


package com.oop.demo05;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 1:51
 */
// 继承关系
public class A extends B{
    // override 重写
    @Override   //注解：有功能的注释！
    public void test() {
        System.out.println("A=>test");
    }
}


package com.oop.demo02;

import com.oop.Demo03.Pet;
import com.oop.demo05.A;
import com.oop.demo05.B;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {
        // 方法的类型只和左边，定义的数据类型有关
        A a = new A();
        a.test();

        // 父类的引用指向了子类
        B b = new A();  // 子类重写了父类的方法
        b.test();
    }
}

多态

动态编译：类型：可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

注意：多态是方法的多态，属性也没有多态

多态注意事项

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系 String Person：类型转换异常：ClassCastException
  3. 存在的条件
    1. 有继承关系
    2. 子类重写父类方法
    3. 父类引用指向子类对象
  4. 以下不可重写
    1. static 方法，属于类，他不属于实例
    2. final 常量：
    3. private 方法：
package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Person {
    public void run(){
        System.out.println("run");
    }
}


package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}


package com.oop.demo02;
import com.oop.Demo06.Person;
import com.oop.Demo06.Student;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {

        // 一个对象的实际类型是确定的
        // new Student();
        // new Person();
        // 可以指向的引用类型就不确定了：父类的引用指向子类
        // Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        // Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run(); // 子类重写了父类的方法，执行子类的方法
        s1.run();
        // 对象能执行哪些方法，主要看对象坐标的类型，和右边关系不大！
        //s2.eat();
        ((Student) s2).eat(); // 高转低
        s1.eat();
    }
}

instanceof （类型转换） 引用类型，判断一个对象是什么类型~

  1. 父类的引用指向子类的对象
  2. 把子类转换为父类，向上转型：
  3. 把父类转化为子类，向下转型：强制转型
  4. 方便方法的调用，减少重复的代码！简洁

抽象：封装、继承、多态！ 抽象类，接口

package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Person {
    public void run(){
        System.out.println("run");
    }
}
package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-05 2:24
 */
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
/*
public static void main(String[] args) {
        // Object > String
        // Object > Person > Teacher
        // Object > Person > Student
        Object object = new Student();

        // System.out.println(X instanceof Y);  // 能不能编译通过，取决于XY之间是否存在父子关系

        System.out.println(object instanceof Student);  // true
        System.out.println(object instanceof Person);   // true
        System.out.println(object instanceof Object);   // true
        System.out.println(object instanceof Teacher);  // false
        System.out.println(object instanceof String);   // false
        Person person = new Student();
        System.out.println("==================");
        System.out.println(person instanceof Student);  // true
        System.out.println(person instanceof Person);   // true
        System.out.println(person instanceof Object);   // true
        System.out.println(person instanceof Teacher);  // false
        // System.out.println(person instanceof String);   // 编译报错

        Student student = new Student();
        System.out.println("==================");
        System.out.println(student instanceof Student);  // true
        System.out.println(student instanceof Person);   // true
        System.out.println(student instanceof Object);   // true
        //System.out.println(student instanceof Teacher);   // 编译报错
        //System.out.println(student instanceof String);    // 编译报错
    }
 */

package com.oop.Demo06;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:14
 */
public class Teacher extends Person{
}

package com;
import com.oop.Demo06.Person;
import com.oop.Demo06.Student;
import com.oop.Demo06.Teacher;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {
    // 静态的方法和非静态的方法区别很大
    // 静态方法：// 方法的调用只和左边，定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {
       // 类型之间的转化：基本类型转换    高->低 强转，低->高 不需要
        // 父->子  强制转换
        Person obj = new Student();
        // Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        ((Student) obj).go();
        new Student();
        Student student = new Student();
        // 低转高  子类转换为父类，可能会丢失自己的本来的一些方法
        Person person = student;
    }
}

Static关键字

package com.oop.demo07;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:58
 */
public class Person {
    //
    {
        // 匿名代码块
    }
    static {
        // 静态代码块
    }
    // 2. 赋初始值
    {
        System.out.println("匿名代码块");
    }
    // 1.
    static {
        System.out.println("静态代码块");
    }
    // 3.

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println("===============");
        Person p2 = new Person();
    }
}


package com.oop.demo07;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 1:46
 */
// static :
public class Student {
    private static int age; // 静态变量  多线程
    private double score; // 非静态变量
    public void run(){
        System.out.println("run");
        go(); // 非静态方法可以调用静态方法中的所有东西
    }
    public static void go(){
        System.out.println("go");
        //静态方法可以调用静态方法中的，不能调用非静态的
    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(s1.age);

        System.out.println(s1.score);
        System.out.println(Student.age);
        // System.out.println(Student.score);
        new Student().run();
        go();
    }
}


package com.oop.demo07;
// 静态导入包
//
import static java.lang.Math.random;
import static java.lang.Math.PI;
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-06 2:03
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
  • 抽象类，不能使用new关键字来创建对象，他是用来让子类继承的
  • 抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类
package com.oop.demo08;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-11 23:56
 */
// abstract 抽象类：类（需要继承）extends:单继承~ 接口可以多继承
public abstract class Action {  //一旦里面有了抽象方法，这个类必须声明为抽象类
    // 约束~有人帮我们实现~
    // abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
    // 1. 不能new这个抽象类，只能靠子类去实现它：约束！
    // 2. 抽象类中可以写普通的方法
    // 3. 抽象方法必须在抽象类中
    // 抽象的抽象：约束
    // 思考？new，存在构造器吗？
    // 存在的意义    抽象出来~   提高开发效率
    public void run(){
        System.out.println("run");
    }
}



package com.oop.demo08;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-11 23:59
 */
// 抽象类的所有方法，继承了它的子类，都必须要实现它的方法~除非这个子类也是抽象的~
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

接口

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有

  • 接口：只有规范！自己无法写方法专业的约束约束和实现分离：面向接口编程~

  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

  • 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

  • OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class，声明接口的关键字是interface

package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:06
 */
// 抽象的思维~ Java 架构师~
// interface 定义的关键字，接口都需要有实现类
public interface UserService {

    // 常量~ public static final int AGE = 99;
    // 一般很少人在接口里面定义常量
    int AGE=99;
    // 接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:13
 */
public interface TimeService {
    void timer();
}


package com.oop.demo09;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 1:10
 */
// 抽象类：extends
// 类可以实现接口 implements 接口
// 实现了接口的类，就需要重写接口中的方法~
// 多继承~利用接口实现多继承~
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口的作用

  1. 约束
  2. 定义一些方法，让不同的人实现~ 10----> 1
  3. public abstrat
  4. public static final
  5. 接口不能被实例化
  6. implements可以实现多个接口
  7. 必须要重写就口中的方法~
  8. 总结博客

内部类

定义

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
  5. lambada
package com.oop.demo10;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 2:44
 */
public class Outer {

    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    // public static class Inner{ 静态内部类，一旦加上static 就拿不到id了
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        // 获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
    // 局部内部类
    public void method(){
        class Inner{
            
        }
    }
}
// 一个java文件中只能有一个public class ，但是可以有多个class
class A{

}


package com.oop.demo10;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-12 2:57
 */
// 思想，操作，关键字
public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        // 没有名字初始化类,不用将实例保存到对象中,匿名内部类
        new Apple().eat();
        UserService userService = new UserService(){

            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}


package com;
import com.oop.demo10.Outer;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
 */
/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-03 2:52
 */
// 一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {
        // new
        Outer outer = new Outer();
        // 通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

异常机制

Exception

什么是异常

  • 实际工作中，遇到的情况不可能是非常完美的。比如：你写某个模块，用户输入的不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们程序再跑着，内存或硬盘可能满了。等等
  • 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
  • 异常指程序运行中出现的不期而至的各种情况，如：文件找不到、网络链接失败、非法参数等。
  • 异常发生在程序运行期间，它影响了正常的程序执行流程
package com.exception;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 22:57
 */
public class Demo01 {
    public static void main(String[] args) {
        new Demo01().a();

    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

// Exception in thread "main" java.lang.StackOverflowError

package com.exception;


/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 22:57
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(11/0);

    }

}
//Exception in thread "main" java.lang.ArithmeticException: / by zero
// 	at com.exception.Demo01.main(Demo01.java:12)
简单分类
  • 检查性异常
    • 最具代表性的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单的忽略。
  • 运行时异常：
    • 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误ERROR：
    • 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到的。
  • 异常处理框架

异常体系结构

  • Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
  • 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

在这里插入图片描述

  • Error
    • Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
    • Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；
    • 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
  • Exception
    • 在Exception分支中有一个重要的子类RuntimeException（运行时异常）
      • ArrayIndexOutOfBoundsException（数组下标越界）
      • NullPointerException（空指针异常）
      • ArithmeticException（算数异常）
      • MissingResourceException（丢失资源）
      • ClassNotFoundException（找不到类）
      • 等异常，这些异常是不检查异常，程序中可以选择捕获异常，也可以不处理。
    • 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
  • Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

Java异常处理机制

快捷键：ctrl + alt + t

异常处理的五个关键字

try、catch、finally、throw、throws

package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 23:53
 */
public class test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {   // try监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){  // 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally{   // 处理善后工作，
            System.out.println("finally");
        }
    }
}


package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-14 23:53
 */
public class test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        // 假设要捕获多个异常：从小到大！
        
        try {   // try监控区域
            System.out.println(a/b);
        }catch(Error e){  // catch(想要捕获的异常类型！)捕获异常
            System.out.println("Error");
        }catch(Exception e){

            System.out.println("Exception");
        }catch(Throwable e) {

            System.out.println("Throwable");
        }finally{   // 处理善后工作
            System.out.println("finally");
        }
    }
    public void a(){b();};
    public void b(){a();};
}

只能捕获一个，就像if…elseif…elseif…else…，且下面必须比上面的范围广

finally 可以不要finally，假设IO，资源，关闭！

抛出异常

try

捕获异常

catch

处理异常

package com.exception;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:11
 */
public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        } finally {
        }
        // Ctrl Alt + T
        try {
            if(b==0){   // 主动抛出异常 throw throws
                throw new ArithmeticException();    // 主动抛出一个异常
            }
            System.out.println(a/b);
        } catch (Exception e) {
            // throw new RuntimeException(e);
            // System.exit(0); //手动结束程序
            e.printStackTrace();  //打印错误的信息
        } finally {

        }
    }
    // 假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){   // 主动抛出异常 throw throws
            throw new ArithmeticException();    // 主动抛出一个异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
}

自定义异常

  • 使用Java内中的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
  • 在程序中使用自定义异常类，大体可以分为以下几个步骤：
    • 创建自定义异常类。
    • 在方法中通过throw关键字抛出异常对象
    • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
    • 在出现异常方法的调用者中捕获并处理异常。
package com.exception.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:50
 */
// 自定义异常类
public class MyException extends Exception{
    // 传递数字>10;
    private int detail;

    public MyException(int a) {
        this.detail = a;
    }
    // toString：异常的打印信息

    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

package com.exception.demo02;

/**
 * @version：java version 1.8
 * @Author：Mr Cao
 * @Description：
 * @Date：2024-02-15 0:58
 */
public class Test {
    // 可能会存在异常的方法
    static void test(int a) throws MyException {
        System.out.println("传递的参数为:"+a);
        if(a>10){
            throw new MyException(a); // 抛出
        }
        System.out.println("ok");

    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            // throw new RuntimeException(e);
            // 增加一些处理异常的代码块
            System.out.println("MyException=>"+e);
        } finally {
        }
    }

}

总结

  • 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
  • 在多重catch块后面，可以加上一个catch（Exceptiton）来处理可能会被遗漏的异常
  • 对于不确定的代码，也可以加上try-catch，处理潜在的异常
  • 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
  • 具体如何处理异常，要根据不同的业务需求和异常类型去决定
  • 尽量添加finally语句块去释放占用资源
曹博Blog
关注
  • 12
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java面向对象编程
qq_45845087的博客
03-20 218
Java面向对象编程 1.什么是面向对象 面向过程思想 步骤清晰简单第一步做什么，第二步做什么… 面向过程适合处理一些较为简单的问题 面向对象思想 物以类聚，分类的思维模型，思考问题首先会解决问题需要哪些分类，然后对这些类进行单独思考。最后，才对某个分类下的细节进行面对过程的思索。 对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。 面对对象编程的本质就是：以类的方式组织代码，以对象的方式封装数据 抽象 三
Java 面向对象编程--异常
黑白土豆的博客
05-09 1035
Java 面向对象编程--异常
JAVA面向对象编程---学生管理系统
wuyomhchang的博客
03-19 4439
今天分享一个简单的Java面向对象编程练习---学生管理系统 首先我们要写一个学生类，属性包含学号，姓名，年龄，居住地，有参无参的构造方法（此处可以Alt+insert+fn（有些电脑需要加fn）直接进行构造~会让你节省很多时间），代码如下 package com.one; /* 学生类 Alt+insert+fn */ public class Student { //学号 private String sid; //姓名 private String nam.
3.16 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类 (10分)
ihopeyousuccess的博客
12-17 4561
16 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类 (10分) 定义类ArrayUtils，在该类内部创建一个静态嵌套类PairResult，该嵌套类包含： 属性: private double min与private double max，用于存放最小值最大值 方法：toString方法，格式见下面的输出样例。 为ArrayUtils类创建一个静态方法PairResult findMinMax(double[] values)，对传递进来的数组找到其中的最大值和最小值并返回PairResu
面向对象编程（Java）.pdf
06-27
包含面向对象编程所有基础知识和实战代码
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类的编写与对象的创建、类的构造函数、类的方法、修饰符、... 可以在轻松幽默的氛围中对面向对象编程产生浓厚的兴趣，从而为后续的编程进阶树立信心。
Java面向对象编程-练习题.34429682.doc
06-28
Java面向对象编程-练习题.34429682.doc
Java-Java面向对象编程教程
11-13
Java 面向对象编程教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Elsaticsearch java基本操作
qq_62383709的博客
07-13 336
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 376
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 436
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2381
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1436
在 Java 中，可以通过多种方法将一个Object转换为Integer。
elk部署springboot
Chihirozy的博客
07-11 274
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3327
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
Java 线程池详解
最新发布
qq_41591215的博客
07-13 632
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 761
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
Java编程实训 Java开发基础入门教程1-05 面向对象编程-封装（共21页）.pptx
12-25
本资源是一份Java编程实训的入门教程，专注于面向对象编程的讲解，特别是第05讲“面向对象编程-封装”。课程从理论到实践，逐步引导学习者理解面向对象编程的核心概念。 首先，封装是面向对象编程中的一个重要特性...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

曹博Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值