面向对象编程

面向对象编程 (oop)

初识面向对象
方法回顾和加深
对象的创建分析
面向对象三大特性
抽象类和接口
内部类及OOP实战

面向对象思想

物以类聚，分类的思维模式

本质：以类的方式组织代码，以对象的组织数据

三大特性

封装
继承
多态

方法回顾 (Demo)

我们首先来看一个例子

public class Demo1 {
    //静态方法 static
            static void a(){
                b();//此时b()是报错的
            }

    //非静态方法
            void b(){
                a();
            }
            //静态方法和类一起加载，而非静态方法则是在对象创建以后才存在
}

因为静态方法和类一起加载，而非静态方法则是在对象创建以后才存在，所以在这个情况如果想用b()方法，需要先创建对象，才能使用

public class Demo1 {
    //静态方法 static
    static void a(){
        Demo1 demo1 = new Demo1();//创建类对象
        demo1.b();
    }

    //非静态方法
    void b(){
        a();
    }
    //静态方法和类一起加载，而非静态方法则是在对象创建以后才存在
}

类与对象的关系

类是一种抽象的数据类型，相当于一个模板。它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物，比如动物、植物
对象是抽象概念的具体实例，比如张三、泰迪

类实例化后会返回一个自己的对象，在使用new关键字创建的时候，会自动给创建好的对象进行默认的初始化

创建与初始化对象

使用new关键字创建对象

一个类即使什么都不写，它也会存在一个方法，这个方法就是构造方法，它有两个特点

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

public class Person {
    public Person() {//默认生成,与类名相同且没有返回值
    }
}

有参构造可以覆盖无参构造

使用new关键字本质上是在调用构造器

如果new后面是没有参数的，则走无参构造，

public class Application {
    public static void main(String[] args) {
        //实例化了一个对象（new）
        Person person = new Person();//此时调用的下面的无参构造
        System.out.println(person.name);
    }
	public class Person{
        String name;
        int age;
        public Person(){
            
        }
    }

}

如果new后面是有参数的，则走有参构造，并且无参构造已经被覆盖，如果再调用无参构造则会报错

public class Application {
    public static void main(String[] args) {
        //实例化了一个对象（new）
        Person person = new Person(String name);//此时调用的下面的有参构造
        System.out.println(person.name);
    }
	public class Person{
        String name;
        int age;
        public Person(String str){
            
        }
    }

}

Alt+Insert快捷键可以快速生成一个构造器

封装

高内聚低耦合

属性私有：get/set

get set

public class Person {
    //属性私有
    private String name;

    //提供一些可以操作这个属性的方法
    //提供一些public 的 get、set方法
    //get 获得这个数据
    //set给这个数据设置值
    public String getName(){   
        return this.name;
    }
    public void setName(String name){  //这里要有参数 并且没有返回值（void）
        this.name=name;
    }


}

public class Application {
    public static void main(String[] args) {
        //实例化了一个对象（new）
        Person person = new Person();
        System.out.println(person.getName());
        person.setName("111");
        System.out.println(person.getName());
    }

按Alt+Insert选择Getter或Setter或者Getter and Setter可以快速生成一个get和set方法

私有化程序以及使用get和set有利于：

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

继承

extends

继承是类和类之间的一种关系。

子类继承了父类，就会拥有父类的全部方法。但如果是私有的则无法继承

public 公共的
protected 受保护的
default 默认的
private 私有的

在Java中，所有的类，都默认直接或者间接继承Object

Java中类只有单继承，没有多继承。

super

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

与this的区别：

this：本身调用者这个对象
super：代表父类对象的应用

前提：

this：没有继承时也可以使用
super：只能在继承条件下才可以使用

构造方法：

this()：当前类的构造方法
super()：父类的构造方法（只能写在子类构造器的第一行）
这两个只能写在构造器中

在子类的构造器中，会有一句隐藏的super();在第一行

重写

为什么需要重写呢？

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

需要有继承关系，子类重写父类的方法
方法名必须相同
参数列表列表必须相同
修饰符：作用域可以扩大但是不能缩小 public > protected > default > private
抛出的异常：范围可以被缩小但不能扩大

重写都是方法的重写，与属性无关

非静态的方法才可以重写，也就是没有static的方法才可以重写

多态

我们先来看个例子

class Animal {
    public void makeSound() {//父类定义方法
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {//子类重写这个方法
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();//此时因为方法不是static静态的，所以animal实际指向的是Dog对象，所以会输出The dog barks
        animal.makeSound();
    }
}

Animal animal = new Dog(); 这行代码创建了一个 Dog 类的对象，但将其引用赋值给了 Animal 类型的变量 animal。在运行时，Java 会根据对象的实际类型（即 Dog 类）来决定调用哪个方法，而不是根据引用类型（即 Animal 类）。这就是所谓的动态绑定或运行时多态。

Static静态方法在多态中的影响

静态方法不支持多态：静态方法属于类，而不属于类的实例。调用静态方法时，是根据引用类型来决定调用哪个方法，而不是根据对象的实际类型。这是因为静态方法在编译时就已经确定了调用的目标，不存在运行时的动态绑定。

class Animal {
    public static void staticMakeSound() {//静态方法
        System.out.println("Static: The animal makes a sound");
    }

    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    public static void staticMakeSound() {//子类重写父类的静态方法
        System.out.println("Static: The dog barks");
    }

    @Override
    public void makeSound() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        // 调用静态方法
        animal.staticMakeSound();//因为方法是静态方法 会根据引用类型 Animal 调用 Animal 类中的 												staticMakeSound 方法，输出 Static: The animal makes a sound
        // 调用实例方法
        animal.makeSound();//由于 makeSound 是实例方法，会根据对象的实际类型 Dog 调用 Dog 类中重写的 makeSound 方法，输出 The dog barks。
    }
}

静态方法不支持多态，调用时只与引用类型有关

多态

可以实现动态编译

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

多态注意事项：

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

instanceof

判断两个类有没有继承关系

class Person{
    
}
class Student extends Person{
    
}
class Teacher extends Person{
    
}
Object object = new Student();
object instanceof Student;//true
object instanceof Person;//true
object instanceof Object;//true
object instanceof Teacher;//false
object instanceof String;//false

Person person = new Student();
person instanceof Student;//true
person instanceof Person;//true
person instanceof Object;//true
person instanceof Teacher;//false
person instanceof String;//编译报错

Student student = new Student();
student instanceof Student;//true
student instanceof Person;//true
student instanceof Object;//true
student instanceof Teacher;//编译报错
student instanceof String;//编译报错

Static关键字

静态

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


    public void run(){

    }

    public static void go(){
    //静态方法
    }
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(Student.age);//静态变量可以直接用类名调用
        System.out.println(Student.score);//而非静态变量不可以用类名调用，此处报错
        student.run();//非静态变量
        go();//静态方法可以直接用类名调用或者直接调用
    }
}

匿名代码块

package oop;
//private 私有
public class Person{
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }

    static {
        //静态代码块）
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("======================");
        Person person2 = new Person();
    }
}
/*此时程序输出结果为
静态代码块
匿名代码块
构造方法
======================
匿名代码块
构造方法

说明每次创建对象时，都会执行一次匿名代码块和构造方法，而静态代码块是只执行一次，之后再创建则不会再执行
*/

抽象类

abstract

注意点：

不能new这个抽象类，只能靠子类去实现他
抽象类中可以写普通的方法
抽象方法必须在抽象类中
抽象类是有构造器的

//抽象类
public abstract class Action {
    //约束：有人帮我们实现
    //abstract抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
	public void print(){  //抽象类中可以写普通的方法
        System.out.println();
    }
}

public class A extends Action{  //继承抽象类后必须重写他的抽象方法
    public void doSomething(){

    }
}

接口

普通类：只有具体实现

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

接口：只有规范

接口的本质是契约

接口的作用：

接口是一个约束
可以定义一些方法，让不同的人实现
在接口中定义的方法默认都是public abstract修饰的
在接口中定义的常量默认都是public static final修饰的，接口中不能定义变量
接口不能被实例化（new），接口中没有构造方法
一个类可以实现多个接口（implements）
必须要重写接口中的所有方法

//interface 定义的关键字
public interface UserService {
    //在接口中定义的都是常量， public static final
    int age = 99;
    //接口中的所有定义其实都是抽象的public abstract
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

// 类 可以实现接口 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() {

    }
}

内部类

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

成员内部类

public class Outter {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{  //定义内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }

}

public class Application {
    public static void main(String[] args) {
        Outter outter = new Outter();

        //通过外部类来实例化内部类
        Outter.Inner inner = outter.new Inner();
        inner.getID();
    }

}

内部类也可以写在方法中

posted @ 2025-04-23 10:50 CtrlRap 阅读(24) 评论(0) 收藏举报

刷新页面返回顶部

ctrlrap