Day06面向对象OOP

面向对象

面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
  • 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，任然需要向面向过程的思路去处理。

什么是面向对象

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

Break和Return的区别

  • break：用于跳出switch ，跳出循环
  • return：用于结束方法，返回值要和方法类型相同

值传递和引用传递

  • 值传递：在使用变量的过程中，会将变量copy到操作栈中进行运输
  • 引用传递：在使用变量的过程中，传递的是对象的地址，根据地址指向的内存数据进行计算

类与对象的关系

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

构造器

  • 一个类即使什么也不写，它也会存在一个方法
  • 类中的构造器也称为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    • 方法名必须和类的名字相同
    • 没有返回值，必须没有返回类型，也不能写void
  • 作用：
    • new 本质是在调用构造方法
    • 初始化对象的值
  • 注意点：定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造

内存分析

类与对象

  • 类是一个模板，类是抽象的，对象是一个具体的实例

封装

  • 高内聚 ，低耦合 高内聚 就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合 ：仅暴露少量的方法给外部使用
  • 封装（数据的隐藏）
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏
  • 属性私有 ， get/set
    • 提高程序的安全性，保护数据
    • 隐藏代码的实现细节
    • 统一接口
    • 系统可维护性增加了

继承

  • 继承的本质是对某一批类的抽象
  • extends ，子类是父类的扩展
  • Java中类只有单继承，没有多继承！
  • 继承是类和类之间的一种关系。
  • 继承关系的两个类，一个为子类，一个为父类。
  • 子类继承了父类，就会拥有父类的全部非私有方法！
  • 私有化的东西无法被继承
  • 在Java中所有的类都默认直接或者间接继承Object类
  • 如果一个类被final修饰 则不能被继承了 final之后断子绝孙了！

super:

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中！
  3. super 和 this 不能同时调用构造方法，因为都必须在第一行
  4. 表示父类对象的应用
  • super VS this ：
    • 代表的对象不同
      • this：本身调用者这个对象
      • super：代表父类对象的应用
    • 前提：
      • this：没有继承也可以使用
      • super：只能在继承条件下才可以使用
    • 构造方法
      • this（）；本类的构造
      • super（）； 父类的构造

方法重写：

  • 前提： 需要有继承关系，子类重写父类方法 是因为父类的方法不足以满足子类的要求，需要方法进行重写
  • 方法名必须相同
  • 参数列表也必须相同
  • 访问修饰符不能够严于父类，注意 private修饰的方法不能被继承，所以不能被重写 （public>protected>default>private）
  • 抛出的异常：范围，可以被缩小，但不能扩大
  • 重写都是方法的重写 和属性无关
  • 静态方法的调用只和左边，定义的数据类型有关
  • 非静态的方法才可以重写

多态

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

  • 有重写才会存在多态！

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

  • 多态存在的条件

    • 有继承关系
    • 子类重写父类的方法
    • 父类引用指向子类的对象：
    • Person person = new Student();

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

    • 父类和子类存在关系，类型也需要为同类型 Class Cast Exception 类型转换异常！
    • static 方法不能被重写 属于类 不属于实例
    • final 修饰的方法 也不能被重写
    • private 修饰的方法 也不能被重写
  • public class Application {
    //一个项目应该只存在一个main方法
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        // new Person();
        //可以指向的引用类型就不确定了
        //Student 能调用的方法都是自己的或者继承父类的！ 但如果重写了父类的方法则 执行重写的那部分
        Student s1 = new Student();
        //父类的引用指向子类 但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();


        s2.run();//子类重写了父类的方法 执行子类的方法
        s1.run();
        //对象能执行那些方法 主要看对象左边的类型！
        ((Student)s2).eat();
        s1.eat();
    }
}

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


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

instance of 和类型转换

  • instanof：用来判断两个类之间是否存在父子关系

  • public class Application {
    //一个项目应该只存在一个main方法
    public static void main(String[] args) {
        //Object>Person>Student
        Object object = new Student();
        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
        System.out.println("================");
        //Object>Person>Student
        //Object>Person>Teacher
        //Object>String
        Person person = new Student();
        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);//编译报错
        System.out.println("================");
        Student student = new Student();
        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);//编译报错
    }
}

  • 类型转换：

    • 子类转换为父类，可能丢失自己本来的一些方法！
    • 把子类转换为父类，向上转型 自动转换
    • 把父类转为子类，向下转型 需要强制转换

static关键字

  • 可以用来修饰方法和属性

  • public class Student {
    private static int age;//静态变量
    private double score ;//非静态变量

    public void run(){
        go();
    }
    public static void go(){
        System.out.println("static go");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);
        s1.run();
        Student.go();
    }
}

  • package com.zhou.oop.Demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

  • abstract :

    • 用来修饰类的时候 就是抽象类
    • 用来修饰方法的时候就是 抽象方法 抽象方法只有方法名字，没有具体实现。需要靠其他类继承通过重写去实现。
    • 抽象类不能被new 只能靠子类继承来实现
    • 一个类只要有抽象方法 那么这个类就必须被声明为抽象类 但抽象类里可以写普通方法
    • 子类必须实现所有的父类抽象方法，否则也要注明abstract

  • 抽象类存在的意义：

    • 更利于代码的维护和重用，因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把相同的属性和方法的组件进行抽象，这样更利于代码和程序的维护，也是Java面向对象的一个重要体现。

接口

  • 自己无法写方法体，只能定义方法，让实现了接口的类去实现，约束和实现分离，面向接口编程。
  • 接口的本质是契约。
  • 接口是面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。
  • 接口声明的关键字 interface
  • 接口中所有的定义方法其实都是抽象的 public abstract
  • 所有在接口中定义的属性都是 public static final 修饰的静态常量
  • 接口不能被实例化，因为接口中没有构造方法
  • 接口都需要有实现类
  • 类可以实现接口 通过implements 利用接口可以实现伪多继承
  • 实现了接口中的类，就必须重写接口中的所有方法
  • 只有一个方法的接口叫做函数式接口，可以使用lambda表达式

内部类

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

    • 成员内部类

    • public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

public class Application {
    //一个项目应该只存在一个main方法
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

    • 静态内部类

    • 局部内部类

    • 匿名内部类

    • public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中 就是匿名内部类
        new Apple().eat();
        UserService userService = new UserService(){

            @Override
            public void hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("apple");
    }
}
interface UserService{
    void hello();
}
posted @   周某人的成神之路  阅读(24)  评论(0)  编辑  收藏  举报
相关博文：
·  Day10注解（Annotation）和反射（Reflection）
·  Day04Java方法
·  面向对象OOP
·  java_day08_1面向对象编程
·  面向对象编程
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae