JAVA面向对象

最新推荐文章于 2022-11-21 22:29:45 发布
最新推荐文章于 2022-11-21 22:29:45 发布
阅读量295 收藏
点赞数
分类专栏： JAVA学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/computer_Melody/article/details/123809702
版权

面向对象

面向对象与面向过程

面向过程思想

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

面向对象思想

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

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

面向对象概述

面向对象编程（Object-Oriented Programming, OOP）

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

面向对象编程是抽象的。

三大特效：

  • 封装
  • 继承
  • 多态

从认识论角度考虑是先有对象后有类。对象是具体的事物。类是抽象的，是对对象的抽象。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

类与对象的创建

类与对象的关系

  • 类是一种抽象的数据类型，它是对某一类事物整体描述或定义，但是并不能代表某一个具体的事物。如动物、植物、手机、Person类、Pet类等，这些类都是用来描述或定义某一类具体的事物应该具备的特点和行为。

  • 对象是抽象概念的具体实例，如张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。对象能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

在程序中，我们不应该为每个类加上main方法，一个程序应该只有一个启动类，即main方法。一个项目应该只存一个main方法。一个类中只存在属性和方法。

创建与初始化对象

  • 使用new关键字创建对象
  • 使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
package com.opp.demo02;

//学生类
public class Student {

    //属性：字段
    String name;
    int age;


    //方法
    public void study(){
        System.out.println(this.name + "在学习");      //this类似于python的self

    }
}

package com.opp.demo02;

//一个项目应该只存一个main方法。
public class Application {
    public static void main(String[] args) {
        
        //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例

        Student student = new Student();

        System.out.println(student.name);       //输出默认值null
        System.out.println(student.age);        //输出默认值0

        student.name = "feng";
        System.out.println(student.name);       //输出feng

        student.age = 3;
        System.out.println(student.age);        //输出3
    }
}

把有main方法的类的界面分离出来，会方便调试

image-20220314100726349

构造器

新建一个Person类，内容为空，但仍然可以new，并且不会报错。

image-20220314104022770

可以打开Person.class文件看一下。在IDEA中打开，需要先添加out文件夹的目录

image-20220314104244093

image-20220314104325487

image-20220314104348801

之后在out的目录下找到Person.class

image-20220314104442707

打开可以看到，里面已经存在了一个方法，与Person.java作对比

image-20220314104701231

那个方法就是一个构造器。可以得出结论：一个类即使什么方法都不写，它也会存在一个方法，即构造器，也叫构造方法。

构造方法是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void
package com.opp.demo02;

public class Person {

    //属性
    String name;

    //显示定义无参构造器
    //实例化初始值
    public Person(){
        this.name = "feng";
    }

    //有参构造:一旦定义了有参构造，还想用无参new对象的话，就必须显示定义无参构造，其实就是方法重载的思想
    public Person(String name){
        this.name = name;
    }

}

package com.opp.demo02;

//一个项目应该只存一个main方法。
public class Application {
    public static void main(String[] args) {

        Person person1 = new Person();

        System.out.println(person1.name);       //输出feng

        Person person2 = new Person("xiao");
        System.out.println(person2.name);       //输出xiao

    }
}

使用alt + insert键可以快速创建构造器，或者通过鼠标右键点击generate

image-20220314111153590

image-20220314111258634

总结

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

  • 构造器的作用：（类似于python的 _init_() 函数)

    • new本质在调用构造方法
    • 初始化对象的值

  • 注意点：在定义了有参构造之后，如果用无参new对象的话，就必须显示定义无参构造，其实就是方法重载的思想

创建对象内存分析

package com.opp.demo02;

public class Pet {

    //属性
    String name;
    int age;

    //方法
    public void shout(){
        System.out.println("啊");
    }
}

package com.opp.demo02;

//一个项目应该只存一个main方法。
public class Application {
    public static void main(String[] args) {

        Pet dog = new Pet();

        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        Pet cat = new Pet();

    }
}

image-20220314115615424

封装

程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合是仅暴露少量的方法给外部使用。

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

JAVA封装记住：属性私有，get/set

package com.opp.demo04;

//学生类
public class Student {

    //属性私有private，私有之后，对象就不能通过.name的方式来调用属性了
    private String name;        //名字
    private int id;     //学号
    private char sex;       //性别
    private int age;        //年龄

    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法

    //get 获得数据
    public String getName() {
        return 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) {       //在set方法里设置一些判断条件，让值的设置变得更安全
        if(age < 120 && age > 0){
            this.age = age;
        }else {
            age = 0;
        }

    }

package com.opp.demo04;

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

        Student s1 = new Student();

        s1.setName("feng");
        System.out.println(s1.getName());       //输出feng


        s1.setAge(999);
        System.out.println(s1.getAge());        //不合法的值，输出0

        s1.setAge(23);
        System.out.println(s1.getAge());        //输出23
    }
}

ctrl + insert或鼠标右键再点Generate, 可以快速生成get/set方法

image-20220315104836486

封装的作用：

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

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

使用关键字 extands

JAVA中类只有单继承，没有多继承。就像一个儿子只有一个爸爸，而一个爸爸可以有多个儿子。

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类。

子类和父类之间，从意义上讲应该具有"is a"的关系。

package com.opp.demo05;

//人的类（父类）
//子类继承父类，子类就会拥有父类中所有的public方法和属性，不过属性在父类中一般是私有的，然后用get/set方法调用
public class Person {

    private int money = 100;

    public void say(){
        System.out.println("说话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package com.opp.demo05;

//学生继承人的类
public class Student extends Person {

}

package com.opp.demo05;

//老师继承人的类
public class Teacher  extends Person{

}

package com.opp.demo05;

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

        Student student = new Student();
        student.say();      //输出说话

    }
}

ctrl + H 键打开当前java的继承树，可以看到当前文件的继承情况。

image-20220315111256999

可以看到Person有两个子类Teacher和Student，也有一个父类Object。

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

super

package com.opp.demo05;

//人的类（父类）
//子类继承父类，子类就会拥有父类中所有的public方法和属性，不过属性在父类中一般是私有的，然后用get/set方法调用
public class Person {

    //无参构造器
    public Person() {
        System.out.println("Person无参执行");
    }

    //受保护的属性
    protected String name = "feng";

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

package com.opp.demo05;

//学生继承人的类
public class Student extends Person {

    //无参构造器
    //子类的构造器会先调用父类的构造器
    public Student() {
        /*
        相当于这里隐藏了一段代码
        super();
        调用父类的构造器必须要在子类构造器的第一行，不然会报错
        如果父类只有有参构造器，那要显式的写出有参的super代码，不然无法调用，因为默认的super是无参调用的
         */
        System.out.println("Student无参执行");
    }

    private String name = "xiao";

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

    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }

    public void test2(){
        print();
        this.print();
        super.print();
    }
}

package com.opp;

import com.opp.demo05.Student;

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

        Student student = new Student();

        student.test1("mei");
        /*
        输出：mei
             xiao
             feng
         */

        student.test2();
         /*
        输出：Student
             Student
             Person
         */


    }
}

super注意点总结：

  • super是调用父类的构造方法，必须在构造方法的第一行。
  • super只能出现在子类的方法或构造方法中。
  • super和this不能同时调用构造方法。
  • this代表本身调用者这个对象，没继承也可以使用；super代表父类对象的引用，只能在继承条件下才可以使用。
  • this(); 表示本类的构造，super(); 表示父类的构造。

方法重写

重写就是子类的方法和父类的方法一致，而方法体不同。

重写注意点：

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

为什么需要重写：父类的功能，子类不一定需要，或者不一定满足。

package com.opp.demo06;

//B作为父类
public class B {
    public void test(){
        System.out.println("B->test()");
    }
}

package com.opp.demo06;

//A类继承B类,重写都是方法的重写，和属性无关
public class A extends B{
    public void test(){
        System.out.println("A->test()");
    }

}

package com.opp;

import com.opp.demo05.Student;
import com.opp.demo06.A;
import com.opp.demo06.B;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();

        /*
        当方法重写时，方法是静态的话，即加了修饰符static时，
        a.test();输出了A->test()，b.test();输出了B->test()。
        而当方法不是静态时，a.test()和b.test()都输出了A->test()。
        可以这样理解：b是A new出来的对象，它调用了A的方法。因为静态方法是类的方法，而非静态是对象的方法，有static时，b调用了B类的方法，因为b是用B类定义的，没有static时，b调用的是对象的方法，而b是用A类new的。
         */


    }
}

不能重写的方法：

  1. static方法属于类，不属于实例
  2. final 常量
  3. private方法

重写快捷键也是ctrl + insert键或鼠标右键点Generate

image-20220316230221164

方法重写成功时，会出现相应的图标

image-20220316230703426

什么是多态

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

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

package com.opp.demo07;

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

}

package com.opp.demo07;

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

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


package com.opp;


import com.opp.demo07.Person;
import com.opp.demo07.Student;

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

        //一个对象的实际类型是确定的，但是可以指向对象的引用类型就不确定了：比如父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        /*
        Student能调用的方法都是自己的或者继承父类的
        而Person作为父类，可以指向子类，但是不能调用子类独有的方法
         */

        s2.run();   //子类重写了父类的方法后，会执行子类的方法
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s2.eat():   //这样调不了，会报错
        s1.eat();


    }
}

注意事项：

  • 多态是方法的多态，属性没有多态
  • 多态需要在有联系的类之间实现，如父类和子类，不然会出现类型转换异常(ClassCastException)
  • 存在的条件：
    • 继承关系
    • 方法重写
    • 父类引用指向子类

instanceof和类型转换

instanceof 用于判断一个对象是什么类型的。

package com.opp.demo08;

//父类
public class Person {


}

package com.opp.demo08;

//子类
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}

package com.opp.demo08;

//子类
public class Teacher extends Person{
}

package com.opp;

import com.opp.demo08.Person;
import com.opp.demo08.Student;
import com.opp.demo08.Teacher;

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

        //Object -> String
        //Object -> Person -> Teacher
        //Object -> Person -> Student
        Object o = new Student();

        System.out.println(o instanceof Student);   //True
        System.out.println(o instanceof Person);    //True
        System.out.println(o instanceof Object);    //True
        System.out.println(o instanceof Teacher);   //False
        System.out.println(o instanceof String);    //False
        System.out.println("===========================");

        Person p = new Student();
        System.out.println(p instanceof Student);   //True
        System.out.println(p instanceof Person);    //True
        System.out.println(p instanceof Object);    //True
        System.out.println(p instanceof String);    //编译报错
        System.out.println(p instanceof Teacher);   //False
        System.out.println("===========================");

        Student s = new Student();
        System.out.println(s instanceof Student);   //True
        System.out.println(s instanceof Person);    //True
        System.out.println(s instanceof Object);    //True
        System.out.println(s instanceof String);    //编译报错
        System.out.println(s instanceof Teacher);   //编译报错

        Object t = new Person();
        System.out.println(t instanceof Student);   //False

        /*
        x instanceof y
        能否通过编译, 看类，x与y的类（实际x和y本身就是类）若存在父子或子父关系则可编译，否则不能通过编译
        编译过后 True/False 看x引用指向对象（例如Object o = new Student(); o的引用指向对象是Student类），x指向的对象如果是y的子类，即是True
        请注意如果x的引用指向对象是y的父类，那也会是False
         */
    }
}

类型转换

package com.opp;

import com.opp.demo08.Person;
import com.opp.demo08.Student;
import com.opp.demo08.Teacher;

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

        //类型之间的转换：父 -> 子 （相当于基础类型的高转低，需要强制转换，而子转父不需要。）
        Person p = new Student();

        p.go();     //报错
        //Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        ((Student) p).go();
        
        //子类转换为父类时，可能丢失自己本来的一些方法
        Student s = new Student();
        s.go();
        Person p2 = s;  //子类转换为父类
        p2.go();    //报错，转换为父类后丢失了go方法
    }
}

父类引用指向子类的对象，但子类不能引用父类的对象。

static关键字

静态变量和方法的调用

package com.opp.demo09;

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);
        System.out.println(Student.score);      //会报错

        run();      //会报错
        new Student().run();        //这样不会报错

        go();       //static方法可以直接调


    }
}

匿名代码块和静态代码块

package com.opp.demo09;

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();
        /*
        输出结果为：
        匿名代码块
        构造方法
         */

        //对象创建完会先走静态代码块，再走匿名代码块，之后再走构造方法。但静态代码块只会执行一次
    }
}

静态导入包

package com.opp.demo09;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

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

        System.out.println(Math.random());

        //通过静态导入包，可以直接使用random()方法
        System.out.println(random());

        //通过静态导入包，可以直接使用PI
        System.out.println(PI);
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那该方法就是抽象方法，对类亦如此。

抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类。

抽象类不能使用new关键字来创建对象，它是用来让子类继承的。

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

子类继承抽象类，必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package com.opp.demo10;

public abstract class Action {

    //abstract抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    //抽象类里面可以有普通的方法
    public void run(){

    }
}

package com.opp.demo10;

//继承了抽象类的子类必须实现抽象类中所有的抽象方法
public class A extends Action{

    @Override
    public void doSomething() {

    }
}

接口的定义与实现

普通类：只有具体实现

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

接口：只有规范

接口是规范，定义的是一组规则，制定好后需要去遵守。

声明类的关键字是class，而声明接口的关键字是interface。

接口不能被实例化，接口中没有构造方法。

implements可以实现多个接口

package com.opp.demo11;

//接口
public interface UserService {

    //接口中定义的所有属性都是常量的public static final, 不过接口一般不定义属性
    int AGE = 99;

    //接口中所有定义的方法都是默认抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.opp.demo11;

public interface TimeService {
    void timer();
}

package com.opp.demo11;

//实现接口的类，必须重写接口中的方法
//利用接口可以实现多继承
public class UserImpl implements UserService, TimeService{
    //通过快捷键 alt+enter 可以快速添上方法的重写

    @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() {

    }
}

内部类

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

package com.opp.demo12;

//外部类
public class Outer {

    private int id = 1;

    public void out(){
        System.out.println("这是外部类的方法");
    }

    //内部类，加上static就是静态内部类
    public class Inner{

        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }

    }

    public void method(){
        //局部内部类，即方法中再有一个类 
        class Inner{
            public void in(){

            }

        }
    }
}

//一个java文件中，可以有多个class类，但是只能有一个public class
class A{

}

package com.opp;

import com.opp.demo12.Outer;

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

        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

package com.opp.demo12;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        new UserService(){
            @Override
            public void hello() {

            }
        };
    }


}

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

interface UserService{
    void hello();
}
LR...?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 3024
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
java面向对象详解
weixin_50073630的博客
10-07 3466
java面向对象详解 1、面向对象基本概念 2、类与对象 3、类和对象的定义格式 4、对象与内存分析 5、封装性 6、构造方法 7、this关键字 8、值传递与引用传递？ 9、对象的一对一关系 10、static关键字 11、main方法分析 12、继承 13、对象的初始化 14、方法的重写 15、super关键字 16、final关键字 17、抽象类 18、接口 19、多态性 20、instanceof关键字 21、内部类 ###################################### 1、
Java面向对象
weixin_73656077的博客
11-21 1915
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面 向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。面向对象的语言中，包含了三大基本特征，即封装、继承、多态。
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
Java面向对象浅谈
编程界明世隐的博客
12-06 4956
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象基础
weixin_60719453的博客
10-13 8411
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java面向对象详解
王梦杰_MengJie
03-07 1万+
1、初识面向对象： 面向过程vs面向对象 面向过程思想：步骤清晰简单，第一步做什么，第二步做什么……，面向过程适合处理一些较为简单的问题 面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程的思路去处理。
Java面向对象试题
热门推荐
光头强的博客
03-19 5万+
1、 请创建一个Animal动物类，要求有方法eat（）方法，方法输出一条语句“吃东西”。 创建一个接口A，接口里有一个抽象方法fly（）。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat（）方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat（）方 法、fly（）方法。 评分标准： 正确写出Ani...
JAVA面向对象学习心得
a18786923310的博客
07-25 1837
java面向对象的知识归纳，包括（继承、封装、多态）等面向对象的特性的总结。
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
最新发布
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
Java面向对象基础练习题
08-06
适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
Java面向对象程序设计
03-17
Java面向对象程序设计是计算机编程领域中的核心主题，它基于面向对象编程（OOP）理念，使得代码更具有模块化、可复用性和易于维护的特点。以下是对标题和描述中涉及的知识点的详细阐述： 1. **第1章：Java入门** -...
Java面向对象编程练习题.pdf
05-22
Java面向对象编程练习题 本资源摘要信息涵盖了 Java 面向对象编程的基础知识，通过三个练习题，展示了 Java 编程语言的基本概念和应用。 练习题 01: 类的成员变量 本练习题展示了 Java 中类的成员变量的概念。类 ...
Java面向对象基础解析
"Java面向对象（基础）" Java面向对象编程是Java语言的核心特性，它使得程序设计更加灵活和模块化。本课程是面向对象的基础入门，适合初学者学习，旨在帮助学生掌握面向对象的基本概念和技能。 1、Java可移植性 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值