JavaSE--面向对象

1. 面向过程 & 面向对象

面向过程思维

面向过程思维--步骤清晰，第一步，第二部...
适合处理一些简单的问题。顺序结构

面向对象思维

物以类聚，分类思维模式。解决问题把总的分类分到单独思考为止，再分类的进行步骤清晰为止
对描述的的复杂事务，为了宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍需要面向过程区处理。

面向对象的编程本质是：以类的方式组织代码，以对象的组织(封装)的数据。

2. 类与对象

对象：是具体的实列。
类：是抽象的，对某类事物的整体描述，不能代表具体的事物。类是对象的模板。

//类
    public class Student{
    //属性
    String name;
    int age;
    
    //方法
    public void study(){
        System.out.println("在学习")
    }
}
//类是抽象的，实列化。
//类实列化后返回一个对象
Student xiaoming=new Student();//具体的人new

3.使用New来创建对象

使用nwe创建后除了分配内存空间，默认进行初始化，以及对类中的构造器的调用。
类中的构造器也成为构造方法，在进行创建对象的时候必要调用的。
构造方法的特点:
1. 必须和类名字相同
2. 必须没有返回类型，也不能写void
作业：
1. 一个来什么都不写，它也会存在一个方法
2. 使用new关键字，本质还是在调用构造器。用来初始化值
```
public class Student{
    //构造方法
    public class(){
        
    }
}
```

值传递和引用传递(具体的值可以改变，如对象。本质还是值传递)

4.面向对象的三大特性

1.封装（数据的隐藏）

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

属性私有：get & set
作用：
1. 提高了程序的安全性，保护数据
2. 隐藏代码实现的细节
3. 统一接口
4. 系统的可维护性增加了

2.继承

Java类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，还有依赖，组合，聚合。

super--this

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

方法的重写

重写需要有继承关系，子类重写父类的方法
方法名和参数列表必须相同
修饰符：范围可以扩大但不能缩小： public>protected>Default>Private
抛出异常：范围可以缩小，不能扩大：
子类的方法和父类方法必须一致，方法体不同。

多态

多态存在条件

有继承关系
子类重写父类方法
父类引用指向子类对象

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

不能重写的方法：

static方法属于类，不属于实列
final 常量
private

instanceof

判断两类之间是否存在父子关系

//Object > Person > Student
//Object > Person > Teacher
//Object > String
Object object =new Student ();
       System.out.println(object instanceof Student);//ture
       System.out.println(object instanceof Person);//ture
       System.out.println(object instanceof Object);//ture
       System.out.println(object instanceof Teacher);//false
       System.out.println(object instanceof String);//false

static(静态类)

静态属性 (静态变量) ---调用时可以直接调用(类名.属性)
静态方法------调用时可以直接调用(类名.方法)
静态代码块---和类一起执行，只进行第一次

静态包---可以直接用方法

package oop.Demo09;
import static java.lang.Math.random; //导入的静态包
public class Student {

    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    static String name;//静态属性
    static int age;    //静态属性
    String gender;     //非静态属性
    public void run(){
        System.out.println("非静态方法");
    }
    public static void go(){
        System.out.println("静态方法");
    }
    public static void main(String[]args){
        System.out.println(random());//静态包的方法
        Student.name=("Lisi"); //静态属性
        Student.age=18; //静态属性
        Student s1=new Student();
        s1.gender=("男");  //非静态属性

        //调用
        s1.run();//非静态方法的调用
        go(); //静态方法的调用
    }
}
//运行结构
静态代码块
0.9773971854846296
匿名代码块
非静态方法
静态方法

抽象类(abstract)

抽象类有子类来实现---》单继承。接口可以是多继承
抽象方法只能定义，不能实现
抽象方法必须在抽象类中
抽象类可以有普通方法

接口(interface)

接口不能实列化，只能定义
implements必须重写方法然后实现

//interface来定义接口
public interface UserServes {
    //默认属性public static final
    int age=18;
	//默认方法public abstract
    void add();
    void delete();
    void update();
    void query();
}
//implements来实现接口
public class UserServiseimpl implements UserServes{
    @Override
    public void add() {}
    @Override
    public void delete() {}
    @Override
    public void update() {}
    @Override
    public void query() {}
}

内部类

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

成员内部类
静态内部类
局部内部类
匿名内部类

发表于 2025-12-03 22:30 Li斯阅读(0) 评论(0) 收藏举报