java4

最新推荐文章于 2024-08-19 03:04:10 发布

原创最新推荐文章于 2024-08-19 03:04:10 发布 · 84 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

7 篇文章

订阅专栏

本文介绍了Java中的面向过程与面向对象编程的概念及其适用场景，详细解析了类、构造器、封装、继承、多态等核心概念，并探讨了抽象类与接口的区别及应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

重温java4

面向过程

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

面向对象

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后是对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
面向对象编程的本质就是：以类的方式组织代码，为复习的组织（封装）数据。

面向对象和面向过程的区分

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

构造器

每个创建的类都有一个默认的构造器，是在进行创建对象的时候必须要调用的
1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void。
3. 实例化对象，给实例化对象赋予初始值。
默认构造器
1. 使用new关键字，必须要有构造器
2. 用来初始化值
3. 有参构造：一旦定义了有参构造，无参就必须显示定义

封装

程序设计要追求“高内聚、低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。
属性私有，get/set

继承

所有的类，都默认直接或者间接继承Object类。
本质是对某一批类的抽象，从而实现对现实世界更好的建模。
Java中只有单继承，没有多继承。
继承是类和类之间的一种关系。类和类之间的关系还有依赖、组合、聚合等。
使用关键字extends。子类继承父类就会拥有父类的全部方法！
父类私有的方法和属性子类无法继承

super与this

super() 方法，调用父类的构造器，必须在子类的第一行，默认是隐藏的不用写。
super必须只能出现在子类的方法或构造方法中！
super和this不能同时调用构造方法！
和this对比：
1. 代表的对象不同：this本身调用者这个对象，super代表服了对象的应用
2. this没有继承也可以使用，super只能在继承条件才可以使用
3. this() 调用的是本类的构造，super() 调用的是父类的构造；

方法重载

重写需要有继承关系，子类重写父类的方法！
- 方法名必须相同，方法体不同。
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小；public>protected>default>private
- 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException -->Exception()
为啥需要重写：
- 父类的功能，子类不一定需要，或者不一定满足！
- 子类重写了父类的方法，执行子类的方法。

作用域	当前类	同一包	子孙类	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

多态

实现动态编译：类型，实现可扩展性
一个对象的实际类型是确定的，可以指向的引用类型就不确定了：父类的引用指向子类的对象
子类能调用的方法都是自己的或者继承父类的！
对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大！
多态是方法的多态，属性没有多态。
父类和子类，有联系才能使用多态，类型转换异常ClassCastException！
存在联系，子类重写父类方法。

public class Demo01 {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的,可以指向的引用类型就不确定了：父类的引用指向子类
        //new student();
        //s1 能调用的方法都是自己或继承父类的！
        Student s1 = new Student();
        Person p1 = new Student();
        Person p2 = new Person();
        
        //对象能执行哪些方法。主要看对象左边的类型，和右边关系不大！
        s1.run();//子类重写了父类的方法，执行子类的方法
        System.out.println("------------");
        p1.run();
        p2.run();
        ((Student) p1).eat();
    }

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

class Student extends Person{
    @Override
    public void run() {
        //super.run();
        System.out.println("Student");
    }

    public void eat(){
        System.out.println("eat");
    }
}

instanceof

判断两个引用之是否存在继承关系

static

有关键字static修饰的方法，为静态方法，在初始化的时候只执行一次。
静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；
静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。

抽象类

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

	//约束~有人帮我们实现
    //abstract 抽象方法
    public abstract void doSomething();

    public void run(){
        System.out.println("sdad");
    }
    /*
        1、不能new这个抽象类，只能靠子类去实现，约束！
        2、抽象类中可以写普通的方法
        3、抽象方法必须在抽象类中
     */

接口

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

异常

Java异常处理是如何工作的，需要掌握以下三种类型的异常：
- 检查性异常：最具代表的检查性异常时用户错误或者问题引起的异常，这是程序员无法预见的。例如：要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
- 错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如：当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
Java把异常当作对象来处理，并定义一个基类Java.lang.Throwable作为所有异常的超类。
Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。