OOP面向对象编程

已于 2024-03-23 15:09:01 修改
阅读量1k 收藏 9
点赞数 7
文章标签： 开发语言 java
于 2024-03-21 12:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzdt19121980228/article/details/136905113
版权

面向对象编程

以类的方式组织代码，以对象的形式封装数据

oop中的抽象到底是什么

当谈论面向对象编程中的抽象时，我们通常指的是将事物的共同特征和行为提炼出来，从而创造出具有通用性和概括性的模型。这些模型可以作为其他具体事物的蓝图或模板，帮助我们思考问题、设计解决方案，以及组织代码。

以更加具体的语言来说：

在 Java 中，抽象通常通过抽象类和接口来实现。抽象类可以包含抽象方法和具体方法，它们用于表示一个概念上的抽象，无法直接被实例化，需要通过子类进行扩展。接口定义了一组方法的契约，它们只描述行为而不提供具体实现，允许不同的类实现相同的接口，从而实现多态性。

在 C++ 中，抽象可以通过纯虚函数和抽象类来实现。纯虚函数是在基类中声明但没有定义的虚函数，它要求子类必须提供实现。抽象类是包含纯虚函数的类，无法被实例化，只能用作其他类的基类。

在 C# 中，抽象可以通过抽象类和接口来实现，与 Java 中的概念类似。

总的来说，抽象帮助我们将问题进行概括和建模，使得代码更具通用性、可维护性和扩展性。通过抽象，我们可以将共性提取出来，从而创建出更具普适性的代码和设计模式。

关于方法的回顾：

  1. 静态方法 static

类名+方法名

//和类一起加载

  1. 非静态方法

实例化这个类

对象类型 对象名 =对象值

//类实例化后才存在

类与对象

类：是一种抽象类型，对某一类事物的整体描述或者定义

对象：就是抽象类型的具体实例

//Application.cpp
package oop.Demo02;
​
public class application {
    public static void main(String[] args) {
​
        //类:抽象的需要实例化
        //类实例化后会返回一个自己的对象
​
        Student student = new Student();
        student.name="八嘎雅鹿";
    }
}
​
//Student.cpp
package oop.Demo02;
//学生类
public class Student {
    //属性,字段
    int age;//0
    String name;//null
​
    //方法
    public void study(){
        System.out.println(this.name+"is studying");//this代表当前这个类
    }
}

构造器

一个类即使什么都不写，也会存在一个方法（即构造方法：没有返回值类型，方法名和类相同）

构造器的核心作用：

  1. 使用new关键字时，必须要有构造器，因为new本质是在调用构造器

  2. 用来初始化值

有参构造：上图是一个无参构造，不写也会默认有一个无参构造，如图所示。

注意：但是如果一旦构造了有参构造，无参构造的定义就必须显示出来

快捷键生成构造器：

Alt+Insert（键盘功能键）

对象内存分析

//方法区也是堆的一部分。

-----------------------------------------

类与对象小结

关于类与对象：

  1. 类与对象

类是一个抽象模板；对象是一个具体实例

  1. 方法

定义、调用、静态or动态方法（static）

  1. 对象的引用

引用类型 除去基本类型（8）种 其他所有的变量类型

对象是通过引用来操作的：栈→堆

  1. 属性：字段Field 成员变量

默认初始化：

数字：0、0.0

char：u0000

boolean:false

引用类型：统统为null

修饰符 属性类型 属性名 = 属性值！

  1. 对象的创建和使用

必须使用new关键字创建对象 构造器

对象的属性：对象名.成员变量名

对象的方法：对象名.方法名（）

  1. 类（只有这两个东西）

静态的属性 属性

动态的行为 方法

-----------------------------------------

封装

高内聚，低耦合：

类的内部数据操作细节均由自己完成，不允许外部干涉；仅暴露少量的类方法给外部使用；

封装：

禁止直接访问一个数据，通过接口操作来实现

作用：

  1. 提高程序安全性，保护数据。

  2. 隐藏代码的实现细节。

  3. 统一接口

  4. 提高系统的可维护性

package oop.Demo03;
​
public class Demo03 {
​
    public static void main(String[] args) {
​
        Student s1 = new Student();
//        si.name=   不合法
        String name= s1.getName();
        s1.setName("baga");
​
        System.out.println(s1.getName());
        s1.setAge(999);
        System.out.println(s1.getAge());
        s1.setAge(70);
        System.out.println(s1.getAge());
    }
}
​
###application.cpp
package oop.Demo03;
​
//类   private：属性私有
public class Student {
    //名字
​
    private String name;
    //学号
​
    private int ID;
    //性别
​
    private char sex;
​
    //年龄
    private int age;
​
​
    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法
​
    //get是获得这个数据
​
    public String getName(){
        return this.name;
    }
    //set是给这个数据设置值
​
    public void setName(String name){
        this.name=name;
    }
​
    public int getID() {
        return ID;
    }
​
    public void setID(int ID) {
        this.ID = ID;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    public int getAge() {
​
        return age;
    }
​
    public void setAge(int age) {
        if(age>120||age<0){
            this.age=3;
        }
        else{
            this.age = age;
        }
    }
}
​
//alt+insert快捷键
/**
 * 自动生成get和set方法
 */
​
###Student.cpp

继承

本质是对某一批抽象的类进行抽象

关键字：extends是扩展的意思：子类是父类的扩展

java只有单继承，没有多继承

继承关系中有两个类：子类（派生类）、父类（基类）

object类

先看代码：

package oop.Demo04;
//子类
public class Students extends Person{
    //快捷键：ctrl+h---------打开继承树
}
​
​
​
//Students.cpp

###

package oop.Demo04;
//父类
//在java中所有的类都默认继承object类，可以用快捷键ctrl+h查看继承树就能看到object类了
public class Person {
    //public
    //private私有的东西是无法继承的
    //default
    //protected
    public void  say(){
        System.out.println("说话：");
    }
​
    private int money=10_0000_0000;
​
    public int getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
}
​
​
//Person.cpp

在java中所有的类都默认继承object类，可以用快捷键ctrl+h查看继承树就能看到object类了

super

super的意思是调用父类的属性方法以及构造器等等。

在Java中，子类会在构造器的第一行自动调用父类构造器：

public class Students extends Person{
    //快捷键：ctrl+h---------打开继承树
    public Students() {
        super();//这行代码是默认执行的
        System.out.println("Person无参构造");}
    //子类会有一个默认代码：super（）;调用父类构造器，而且必须在子类的第一行
}

注意点：

  1. super调用父类的构造方法，必须在构造方法的第一个

  2. super必须只能出现在子类的方法或者构造方法中

  3. super&this不能同时调用构造方法

VS this

this:调用者本身这个对象

super：代表父类对象的引用

前提

this：没有继承也可以使用

super：只能在继承条件下使用

构造方法：

this（）：本类的构造

super（）：父类的构造

方法重写

package oop;
​
import oop.Demo04.Students;
import  oop.demo05.B;//使用哪个类的文件必须包括这个包
import oop.demo05.A;
​
public class Application {
    //静态方法与非静态方法区别很大
        //static：//方法的调用只和左边，定义的数据类型相同
    public static void main(String[] args) {
​
​
        A a = new A();
        a.test();
​
        //父类的引用指向子类
        B b = new A();//子类重写了父类的方法
        b.test();
​
​
    }
}
​
//Application.cpp
package oop.demo05;
//继承
public class A extends B{//A是B的子类
​
​
    //Override重写
    @Override//注解，给人看的
    public void test() {
        System.out.println("baga");
}
​
​
//A.cpp
package oop.demo05;

//重写都是方法的重写，和属性无关
public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}



//B.cpp

重写：需要有继承关系，子类重写父类的方法

  1. 方法名必须相同

  2. 参数列表相同

  3. 修饰符：范围可以扩大，但是不能缩小。public>protected>default>private

  4. 抛出的异常：范围可以被缩小，但不能扩大。ClassNotFindException-->Exception(大)

重写就是子类的方法和父类的方法必须要一致，方法体不同

为什么需要重写？

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

alt+insert+override

多态

动态编译：类型可扩展

什么是多态：同一个方法根据发送对象不同而采取多种不同的行为方式。

package oop;

import oop.Demo04.Students;
import oop.demo05.B;//使用哪个类的文件必须包括这个包
import oop.demo05.A;
import oop.demo06.Person;
import oop.demo06.Student;

import java.rmi.StubNotFoundException;

public class Application {
    //静态方法与非静态方法区别很大
        //static：//方法的调用只和左边，定义的数据类型相同
    public static void main(String[] args) {
        //一个对象的实际类型是确定的，但它指向的引用类型不确定
        //子类能调用的方法1.自己的2.父类的
        Student s1 = new Student();

        Person s2 = new Person();

        //父类可以指向子类，但是不能调用子类独有的方法，子类重写时，父类会调用子类对应的那个方法
        Person s3 = new Student();//父类的引用指向子类的类型

        //***对象能执行哪些方法，主要看对象左边的类型，和右边关系不大***(类型引用除外)
        s3.run();//子类重写了父类的方法，执行子类的方法！！！//Son
        s2.run();//This function call.
        s1.run();//Son
        s1.eat();//eat
        s2.eat();//(报错)

        //类型转换 ：括号加一个类型，从高类型转到低类型需要强制转换，从父类到子类也需要
        ((Student)s2).eat();

    }
}

//Application.cpp
package oop.demo06;

public class Person {
    public  void run(){
        System.out.println("this function call.");
    }
}
//Person.cpp
package oop.demo06;

public class Student extends Person {//继承


    @Override
    public void run() {
        System.out.println("son");//重写
    }

    public void eat(){

        System.out.println("eat");
    }
}
//Student.cpp

关于以上代码以及多态的说明:

  1. 多态是方法的多态,属性没有多态

  2. 父类和子类有联系——类型转换异常：ClassCastException

  3. 存在条件：继承关系；方法重写；父类引用指向子类对象

    Father f1 = new Son();

  4. 有些方法不能被重写：

    1. static 静态方法：属于类，不属于任何实例

    2. final 常量池中

    3. private 私有不能重写

  5. 关于类型转换

    //类型转换 ：括号加一个类型，从高类型转到低类型需要强制转换，从父类到子类也需要
    ((Student)s2).eat();

instanceof&类型转换

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

实际上：是检查对象所在类型树上有否有右侧的类

package oop;

import oop.Demo04.Students;
import  oop.demo05.B;//使用哪个类的文件必须包括这个包
import oop.demo05.A;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;

import java.rmi.StubNotFoundException;

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

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

        System.out.println("========================");

        Person person = new Student();
        System.out.println(person instanceof  Student);//true
        System.out.println(person instanceof Teacher);//false
        System.out.println(person instanceof  Person);//true
        System.out.println(person instanceof  Object);//true

        System.out.println("========================");
        Student student = new Student();
        System.out.println(student instanceof  Student);//true
//        System.out.println(student instanceof Teacher);//false
        System.out.println(student instanceof  Person);//true
        System.out.println(student instanceof  Object);//true
    }


}

//Application.cpp

类型转化

package oop;

import oop.Demo04.Students;
import  oop.demo05.B;//使用哪个类的文件必须包括这个包
import oop.demo05.A;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;

import java.rmi.StubNotFoundException;

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

        //类型之间的转换：基本类型转换   高低
        //高                  //低
        Person obj = new Student();

//        student将这个对象转换为Student类型，我们就可以使用Student方法了

        Student student = (Student) obj;    //高转低，通过强制转换
        student.go();

        ((Student) obj).go();
    }


}

//Application.cpp
package oop;

import oop.Demo04.Students;
import  oop.demo05.B;//使用哪个类的文件必须包括这个包
import oop.demo05.A;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;

import java.rmi.StubNotFoundException;

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

        //类型之间的转换：基本类型转换   高低
        //子类转换为父类，可能会丢失一些方法！（go（）；）
        Student student = new Student();
        Person person = student;    //高转低，自动转换
        person.run();

    }


}

//Application.cpp
/*
1.父类引用指向子类对象
2.把子类转化为父类，向上转型：不用强制转换。
3.把父类转化为子类，向下转型：只用强制转换。
4.方便方法调用，减少代码重复！

抽象：封装、继承、多态     抽象类、接口
 */

/* 1.父类引用指向子类对象 2.把子类转化为父类，向上转型：不用强制转换。 3.把父类转化为子类，向下转型：只用强制转换。 4.方便方法调用，减少代码重复！

抽象：封装、继承、多态 抽象类、接口 */

static关键字

与项目同时创建

java中的static是什么

在 Java 中，static 是一个关键字，可以用来修饰成员变量、方法或代码块。使用 static 关键字可以使被修饰的成员与类相关联，而不是与类的实例（对象）相关联。具体来说，static 可以有以下几种用法：

  1. 静态变量（类变量）：被 static 关键字修饰的成员变量称为静态变量或类变量。静态变量属于类，而不是对象，只会在类加载的时候初始化一次，所有实例共享同一份静态变量。可以通过类名直接访问静态变量，如 ClassName.staticVariable。

  2. 静态方法：被 static 关键字修饰的方法称为静态方法。静态方法可以直接通过类名调用，无需实例化对象。静态方法中不能直接访问非静态成员，因为非静态成员需要通过对象实例来访问。

  3. 静态代码块：使用 static 关键字定义的代码块称为静态代码块。静态代码块在类加载时执行，只会执行一次，用于初始化静态变量或进行静态资源的加载工作。

  4. 静态内部类：使用static关键字修饰的类称为静态内部类，可以直接通过类名来调用而非对象

静态成员属于类而不是对象，在内存中只有一份副本，可以通过类名直接访问，适合用于定义在全局范围内共享的变量和方法。需要注意的是，静态成员不能访问实例变量和实例方法，也不能使用 this 关键字。

package oop.demo07;

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

    public  void  run(){

    }

    public static void go(){//静态方法

    }
    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
        go();//因为静态方法是和类一起加载的，因此也可以直接调用，不写类名。同理，静态变量夜可以不写类名
        //或者
        Student.go();//通过类来调用
        ----------------------
        Student student = new Student;
        stufent.run();//非静态方法必须通过对象实例来调用
    }
}
package oop.demo07;

public class Person {
    //2
    {
        //匿名代码块
        System.out.println("匿名代码块");
    }
    //1
    // static只执行一次~
    static{
        //静态代码块
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("======================");
        Person person2 = new Person();
    }
}

about final

package 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);
    }
}
//补充：
//final修饰符：用final修饰过之后就不能可以被继承了——final是断子绝孙修饰符

about java 虚拟机（）JVM

Java 虚拟机（Java Virtual Machine，JVM）是 Java 运行时环境的一部分，它是一个虚拟的计算机，负责执行 Java 字节码（bytecode）并管理 Java 应用程序的运行。JVM 提供了内存管理、垃圾回收、安全性、线程管理和其他运行时支持，使得 Java 程序可以在不同的操作系统上运行，实现了“一次编写，到处运行”的特性。JVM 的作用主要包括以下几个方面：

  1. 字节码执行：JVM 负责将 Java 源代码编译成字节码，并执行这些字节码以实现程序的运行。

  2. 内存管理：JVM 负责内存的分配与回收，包括堆（Heap）、栈（Stack）、方法区（Method Area）等内存空间的管理。

  3. 垃圾回收：JVM 中的垃圾回收器（Garbage Collector）负责自动回收不再使用的内存，并释放资源，避免内存泄漏。

  4. 安全性：JVM 提供了安全沙箱机制，限制程序对系统资源的访问，确保程序的安全性。

总的来说，JVM 充当了 Java 程序与操作系统之间的中间层，负责将 Java 代码翻译成可由底层操作系统执行的指令，同时提供一些运行时环境支持。这使得 Java 的跨平台特性得以实现，Java 程序可以在不同的平台上运行而无需修改代码。

抽象类

package oop.demo08;

public  abstract class Action {

    //约束~有人帮我们实现
    //abstract 抽象类，只有方法名字，没有方法实现
    public abstract void dosomething();

    //抽象类特点
    //1.不能new这个抽象类（抽象类不能实例化），他只能靠子类来实现他
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中

}

接口

普通的类：只有具体实现

抽象的类：具体实现和抽象方法都有

接口：只有规范！自己无法写方法

抽象类：只能单继承

接口：可以多继承

package oop.demo09;

//定义的关键字：interface       接口都会有一个实现类
public interface UserService {
    //接口中的所有定义的属性默认有public、static、final的
//    public static final int age = 99;
    int age = 99;//一般很少在接口中定义属性
    //接口中的所有定义的方法都是抽象的、公开的
//    public abstract void run(); //public abstract是默认的
    //因此可以直接写：
    void run();
    void delete(String name);
    void update(String name); 
    void query(String name);
}
//UserService.java
package oop.demo09;

public class UserServiceimpl implements UserService,TimeService{//可以额外实现多个接口如TimeService.java
    @Override
    public void run() {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void timer() {

    }

    @Override
    public void query(String name) {


    }
}
//UserServiceimpl

接口的作用：

  1. 约束

  2. 定义一些方法，让不同的人实现~

  3. 接口中默认的方法都是public abstract

  4. 默认的属性都是public static final

  5. 接口不能被直接实例化，接口中没有构造方法。（抽象类都不能被实例化，跟别提接口了）

  6. implements可以实现多个接口

  7. 必须要重写接口中的方法

JNI OOP 面向对象编程接口设计
凯尼
03-05 734
在使用JNI 面向对象编程(OOP)时，Java端如何处理好Native引用生命周期管理及相关接口设计，以及过程中带来的维护问题。
PHP面向对象程序设计OOP继承用法入门示例
10-20
继承是面向对象编程的一个核心概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。 首先，让我们看看PHP类的定义。在PHP中，使用关键字class来定义一个类。类可以包含属性和方法。属性通常是变量，用于...
面向对象—抽象
Roy的IT笔记
12-28 8065
面向对象分析与设计的主要任务是，找出类和对象，构建对象模型。 对象模型的主要要素：抽象、封装、模块化与层次结构。 对象模型的次要要素：类型、并发、持久。 抽象描述了一个对象的基本特征,可以将这个对象与所有其他类型的对象区分开来，因此提供了清晰定义的概念边界，它与观察者的角度有关。 抽象关注一个对象的外部视图，用来分离对象的基本行为和实现。我们可以理解为抽象关注接口，即可观察到的
面向对象最重要的是“抽象”，三层最重要的也是“抽象”，没有抽象就不是真正的面向对象、三层。
jyk 金色海洋工作室 ASP.NET经验总结
05-01 8865
  　　只用class的，那叫做“基于对象”，比如当初的vb6.0；只是分了三个项目，把以前写在一起的代码分成了三份，所谓的业务逻辑层就是一个传声筒，这一类自称三层的，在我看来都是“模仿三层”，甚至是“伪三层”。 　　面向对象，就是要先考虑“对象”，考虑对象的时候完全不用去考虑数据库结构是什么样子的，这个对吧？ORM讲究的是现有O后有R，然后再去映射。 代码
面向对象编程的四大基石：抽象、多态、继承、封装
一起coding，一起嗨。
02-10 959
面向对象编程的四大基石：抽象、多态、继承、封装
Java面向对象编程之抽象
ruan_luqingnian的博客
01-27 1098
Java面向对象编程之抽象 讲解抽象的好处，抽象类和抽象⽅法 什么是抽象 需求 动物都有年龄和名称，但是吃的不⼀样，⽺吃草，⽼⻁吃⾁，但是都是闭着眼睛睡觉的 ⻋，都有名称和价格，也有跑的⽅法，但是最⾼速度或者动⼒来源不⼀样 当⽗类的某些⽅法不确定时，可以⽤abstract关键字来修饰该⽅法，即抽象⽅法，⽤abstract来修饰该类，即抽象类 抽象类将事物的共性的东⻄提取出来，由⼦类继承去实现，代码易扩展、易维护 java中的抽象类和抽象⽅法 //抽象类 abstract class 类名{
面向对象编程思想-抽象
实践求真知
04-22 304
一 抽象的介绍 我们在定义一个结构体时，实际上就是把一类事物的共有的属性(字段)和行为( 方法)提取出来，形成一个 物理模型(结构体)。这种研究问题的方法称为抽象。 二代码 package main import ( "fmt" ) // 定义一个结构体 Account type Account struct { AccountNo string Pwd string Balance float64 } // 方法 // 存款 func (acco.
面向对象地本质-抽象
Computer Graphics Changes Your Life
06-07 5118
   什么是面向对象的本质？近日在阅读一位网友在CSDN博客上发表的文章，作者认为对象，对象的职责，以及对象之间的交互构成了OO思想的本质。在我看来，抽象更接近OO思想的本质。我是从以下几点考虑的:1.抽象使我们更接近于事物的本质。抽象的过程就是一个提炼存在于事物之间共同拥有的元素，而这些事务之间共同拥有的元素往往是这一事物区别于其他事物关键的东西，这些元素就构成了事物的本质。2.抽象的思
JavaScript OOP面向对象编程课程代码
最新发布
03-17
JavaScript OOP面向对象编程课程代码
oop.rar_oop_面向对象_面向对象程序设计
09-14
在 OOP 中，"oop.ppt" 可能是一个关于面向对象编程的 PowerPoint 演示文稿，涵盖了上述概念的详细讲解，可能还包括实例和案例分析，帮助理解 OOP 的实际应用。而 "www.pudn.com.txt" 文件可能是从网络资源 ...
oop面向对象编程之打飞机游戏源码
11-26
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，将数据和操作数据的方法封装在一起。在打飞机游戏中，我们可以看到OOP的广泛应用，通过创建不同的对象来模拟游戏中的...
11.面向对象编程思想——抽象
weixin_43893483的博客
08-11 398
1. 如何理解抽象 我们在前面去定义一个结构体时，实际上就是把一类事物的共有的属性（字段）和行为（方法）提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。 package main import ( "fmt" ) // 定义一个结构体Account type Account struct { AccountNo string Pwd string Balance float64 } // 方法 // 1. 存款 func (account *Account) D.
java面向对象编程——抽象和接口
weixin_46048259的博客
04-01 1091
第九章、抽象类 一、抽象方法和抽象类 抽象：abstract修饰，没有实体，其实现内容交给子类完成 1.抽象类 -由abstract修饰的类，有抽象方法的类就是抽象类 - 有抽象方法的类，一定是抽象类 - 抽象类可以有非抽象方法 -一个类没有抽象方法也可以修饰为抽象类 - 抽象类不能被实例化 //抽象类 public abstract class Shape { } ​ ​ public class TestSh...
C++面向对象编程特性（封装、抽象、继承、多态）
bx1091182836的博客
11-06 1305
面向对象编程是一种编程范式或编程风格。它以类或对象作为组织代码的基本单元，并将封装、抽象、继承、多态四个特性，作为代码设计和实现的基石 。
数据抽象与面向对象编程
揣金磊 的博客
01-12 412
抽象类（java面向对象编程）
lrl2414451992的博客
09-19 353
2.1 例子 我们还是定义一个动物管理系统，写出每个动物的叫声，因为每个动物都需要会叫这个行为，但是每个动物的叫声的情况又不一样，我们就可以写一个抽象类（父类）来写出所有动物会叫这个方法，每个动物继承这个抽象类（父类），写出各自自己的叫声。#我们需要着重知道：抽象类不能创建对象，仅仅就是为了被子类继承的，而且被子类继承后，需要在子类中重写抽象类的抽象方法（否则这个类也需要定义成抽象方法），然后在main函数中就可以用子类对象来调用父类的（抽象类）的抽象方法。抽象方法是没有方法体的！
面向对象程序设计-抽象类
KALA_K的博客
11-14 683
抽象类 在Java中抽象类有以下规定： （1）抽象类不能被实例化，只有抽象类的非抽象子类才可以被实例化。 （2）抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。 （3）抽象类中的抽象方法只是声明，不包含方法体。 （4）构造方法和类方法（用static修饰的方法）不能声明为抽象方法。 （5）抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。 定义抽象类时，需要使用abstract关键字，定义抽象类的语法如下： [权限修饰符] abstract class 类
07-面向对象基础 （抽象）
yc_Cabbage的博客
08-05 1153
Java面向对象--抽象
OOP面向对象编程练习解析与实现
面向对象编程是一种计算机编程范式，它使用"对象"来设计软件。对象可以包含数据（通常被称为属性或字段）以及代码（通常被称为方法）。OOP的概念和原则允许程序员通过创建类（class）来描述这些对象，并通过创建类的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值