面向对象OOP

初始面向对象

面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对分类进行独立思考。最后，才对某个分类下的细节进行面向过程的思索。
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但，从具体到微观操作，仍需要面向过程的思路去处理。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
三大特性：封装；继承；多态
从认识角度考虑，先有对象后有类；从代码角度考虑，先有类后有对象。

方法回顾与加深

方法的定义：修饰符、返回类型、break（跳出switch结束循环）和return的区别、方法名、参数列表、异常抛出

package com.kuang.OOP;

public class Demo01 {
    public static void main(String[] args) {
        
    }
    /*
     修饰符  返回值类型  方法名（参数）{
          //方法体
          return 返回值；
         }
    */
    public String sayHello(){
        return "hello,world!";
    }
}

方法的调用：静态方法(static)、非静态方法、型参与实参、值传递与引用传递、this关键字

package com.kuang.OOP;
//引用传递：对象，本质还是值传递
public class Demo02 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo02.change(person);
        System.out.println(person.name);
    }

    public static void change(Person person) {
        //person是一个对象：指向的-->Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "张三";
    }
}

//定义了一个person类，有一个name属性
class Person{
    String name;
}

对象的创建分析

类与对象的关系：

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物。
对象是抽象概念的具体实例。

创建与初始化对象

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

package kuang.OOP;

public class Application {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是Student类的具体实例
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 21;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming);
        xiaohong.name = "小红";

    }
}

类中的构造器也称为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

package kuang.OOP;

public class Person1 {
    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    String name;

    //实例化初始值
    //1、使用new关键字，本质是在调用构造器
    //2、初始化对象的值
    //无参构造
    public  Person1(){
        this.name = "张三";
    }
    //有参构造：一旦定义了有参构造，无参就必须显式
    public Person1(String name){
        this.name = name ;
    }
    
    //**alt+insert一键生成有参和无参**
}

面向对象三大特性

封装####

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

提高程序安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护增加了

package kuang.OOP.Demo01;

public class Student {
    //属性私有
    private String name;
    private int age;
    private  char sex;

    //提供一些可以操作这个属性的方法
    //提供public的get/set方法
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //**alt+insert一键生成**
}

继承####

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

package kuang.OOP.demo02;

public class Person {

    private  int money = 999;
    public  void  say(){
        System.out.println("说话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {

        this.money = money;
    }
}

子类:

package kuang.OOP.demo02;

public class Student extends Person{
}

JAVA中类只有单继承，没有多继承。
继承是类与类之间的一种关系。除此之外，类与类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系。
Ctrl+H：打开继承树
object类：Java中所有的类，无论是否显示写extends继承父类，最终都会默认继承object类。
super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

super和this比较：

代表的对象不同：this指本身调用者这个对象；super代表父类对象的应用
前提:this没有继承也可以使用；super只能在继承条件才可以使用
构造方法：this（）是本类的构造；super（）是父类的构造

创建子类对象时，先调用父类的构造方法完成初始化，再执行子类自己的构造方法。
方法的重写
需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大：public>Protected>Default>private
抛出的异常：范围可以被缩小，但不能扩大

重写，子类的方法和父类必要一致：方法体不同！
为什么要重写：

父类的功能，子类比一定需要，或者不一定满足

//父类
package kuang.OOP.demo03;
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

//子类
package kuang.OOP.demo03;

public class A extends B{
    @Override //重写（alt+insert;override）
    public void test() {
        //super.test();
        System.out.println("A=>test()");
    }
}

import kuang.OOP.demo03.A;
import kuang.OOP.demo03.B;

public class Application {
    public static void main(String[] args) {

        //静态写法：方法的调用之和左边有关，定义的数据类型有关
        //非静态写法：重写
        A a = new A();
        a.test();

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

多态####

编译看左边，执行看右边
多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系
存在条件：继承关系，方法需要重写，父类引用指向子类对象

同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

父类
package kuang.OOP.demo04;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

子类
package kuang.OOP.demo04;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat good");
    }
}

package kuang.OOP;

import kuang.OOP.demo04.Person;
import kuang.OOP.demo04.Student;
import kuang.OOP.demo03.A;
import kuang.OOP.demo03.B;

public class Application {
    public static void main(String[] args) {

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

父类引用指向子类的对象
把子类转换成父类，向上转型
把父类转换成子类，向下转型；强制转换
方便方法的调用，减少重复的代码
instanceof（类型转换）
static

抽象类与接口

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类，如果用来修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。

抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，他是用来让子类实现的。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！自己无法写方法~~约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界“如果你是...则必须能...”思想。
接口的本质就是契约，就像法律，制定好大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。
声明类的关键字是class，声明接口的关键字是interface

//接口
package kuang.OOP.demo06;

//接口都需要有实现类
public interface UserService{
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    
}

package kuang.OOP.demo06;

//类 可以实现接口----implements 接口
//是极限了接口的类，就需要重写接口中的方法

//多继承，利用接口
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void delete(String name) {
        
    }

    @Override
    public void add(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void timmer() {
        
    }
}

接口的作用：

约束
定义一些方法，让不同的人实现
方法都是public abstract
常量都是public static final
接口不能被实例化
implements可以实现多个接口
必须要重写接口中的方法

内部类及OOP实战

内部类就是一个类的内部在定义一个类。

package kuang.OOP.demo07;

public class Outer {
    private int id=11;
    public void out(){
        System.out.println("这是外部类方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("内部类方法");
        }

        /*//获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }*/
    }
}
//一个Java类中可以有多个class类，但是只能有一个public class
class A{
    
};

package kuang.OOP;

import kuang.OOP.demo07.Outer;

public class Application {
    public static void main(String[] args) {

        Outer outer = new Outer();
        //通过外部类实例化内部类
       /* Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();*/

异常-Exception

检查性异常
运行时异常
错误ERROR：不是异常，而是脱离程序员控制的问题。
异常处理机制
抛出异常
捕获异常
异常处理关键字：try、catch、finally、throw、throws

package kuang.exception;

/*public class Test {
    public static void main(String[] args) {

    int a = 6;
    int b = 0;


        //Ctrl+Alt+T
    //假设要捕获多个异常：从小到大
    try {//try监控区域
        if(b==0){
         throw new ArithmeticException();//主动抛出异常
        }

        System.out.println(a/b);
    }catch(ArithmeticException e){//catch（想要捕获的异常类型）捕获异常
        System.out.println("异常");
        e.printStackTrace();//打印错误的栈信息
    }catch (Throwable t){
        System.out.println("Throwable");
    } finally {//处理善后工作
        System.out.println("执行finally");
    }
}
}
*/
public class Test{
    public static void main(String[] args) {
        try{
            new Test().test(6,0);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }
    }
    //假设方法中处理不了异常。方法上抛出异常
    public void test(int a,int b)throws ArithmeticException{
        if (b==0){
            throw new ArithmeticException();//主动的抛出异常，一般在方法中使用。
        }
    }
}

自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
使用自定义异常类，大体步骤：

创建自定义异常类
在方法中通过throw关键字抛出异常
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
在出现异常方法的调用者中捕获并处理异常

package kuang.exception.demo02;

public class MyException extends Exception{
    //传递数字 >10
    private int detail;

    public MyException(int detail) {
        this.detail = detail;
    }

    //toString 异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
在多重catch快后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单地调用printStackTrace（）去打印输出
具体如何处理异常，要根据不同业务需求和异常类型去决定
尽量添加finally语句去释放占用的资源

posted @ 2026-01-21 21:48 Dominus 阅读(0) 评论(0) 收藏举报

刷新页面返回顶部