Java面向对象

最新推荐文章于 2025-05-17 17:00:09 发布
最新推荐文章于 2025-05-17 17:00:09 发布
阅读量899 收藏 10
点赞数 15
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77110245/article/details/147596241
版权

一、面向过程与面向对象

1.面向过程思想（pop）：以函数和流程为中心，将问题分解为一系列步骤，通过函数调用逐步实现。其设计理念是“自顶向下”，适合线性逻辑。

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

2.面向对象思想（oop）：以对象为中心，将问题抽象为具有属性和方法的实体，通过对象交互解决问题。其设计理念是“自底向上”，强调现实世界的抽象。

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

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

二、什么是面向对象（oop）

  1. 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据。
  2. 抽象
  3. 三大特性：
  • 封装
  • 继承
  • 多态
  1. 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
  2. 从代码运行角度考虑是先有类后有对象。类是对象的模板。

三、类与对象的关系

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是不能代表某一个具体的事物
  1. Person类，Pet类，Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
  • 对象是抽象概念的具体实例。
  1. 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  2. 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

(一) 创建与初始化对象

  • 使用new关键字创建对象。
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void。
  • 作用：
  1. 使用new关键字，本质是在调用构造器
  2. 用来初始化值
  • 注意点：定义有参构造之后，如果想使用无参构造，必须显示的定义一个无参的构造
  • 示例
package oop.demo02;
public class Person {
    //一个类就算什么都不写，也会存在一个方法
    String name;  //定义属性

    //显示的定义构造器
    //无参构造器
    public Person() {
        this.name = "懒洋洋";
    }
    //有参构造:一旦定义了有参构造，无参构造必须显示定义
    public Person(String name) {
        this.name = name;
    }
}
package oop.demo02;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        // new 实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);
    }
}

(二) 创建对象内存分析

package oop.demo03;
public class Pet {
    public String name;
    public int age;
    public  void shout(){
        System.out.println("叫了一声");
    }
}
package oop.demo03;
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();
    }
}

总结：

1.类是一个模板，是抽象的；对象是一个具体的实例。

2.方法的定义与调用

3.对象是通过引用来操作的：栈->堆

4.属性：字段 成员变量 默认初始化 修饰符 属性类型 属性名 = 属性值

5.对象的创建与使用：必须使用new关键字创造对象

6.类：静态的属性 动态的行为（方法）

四、封装

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

public class Student {
    //属性私有 private
    private String name; //名字
    private int id;  //学号
    private int age;  //年龄
    private char sex; //性别
    
    //提供一些可以操作这个属性的方法
    //提供一些public 的get set方法

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age < 0 || age > 120) {   //做安全性的验证判断
            this.age = 0;
        }else {
            this.age = age;
        }
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
}
package oop.demo04;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("懒洋洋");
        student.setAge(150);  //不合法
        System.out.println(student.getName());
        System.out.println(student.getAge());
    }
}
  • 作用：
  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口（get set）
  4. 提高系统可维护性，便于修改内部代码

五、继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extends的意思是“扩展”。子类是父类的扩展。
  • Java中只有单继承，没有多继承！
  • 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
  • 子类和父类之间，从意义上讲应该具有“is a”的关系
package oop.demo05;
//在java中，所有的类都默认直接或间接继承Object类
//Person：父类
public class Person {
    //封装
    private int money = 1000000;

    public int getMoney() {
        return money;
    }

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

    public void say(){
        System.out.println("说了一句话");

    };
}

package oop.demo05;
//学生 is 人：派生类 子类
//子类继承了父类，就会拥有父类的所有方法
public class Student extends Person {
}
package oop.demo05;
public class Application {
    public static void main(String[] args) {
        Student s = new Student();
        s.say(); //student类继承了person类的say()方法
        System.out.println(s.getMoney()); //student类继承了person类的属性
    }
}
  • super 与 this的区别
  1. 代表的对象不同：

     ①this：本身调用者这个对象

     ②super：代表父类对象的应用

  2. 前提：

    ①this：没有继承也可以使用

    ②只能在继承条件下才能使用

  3. 构造方法：

        ①this()：本类的构造

        ②super():父类的构造

  • super：
  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法
package oop.demo05;
//在java中，所有的类都默认直接或间接继承Object类
//Person：父类
public class Person {
    protected String name = "lyy";
    public void print(){
        System.out.println("Person");
    }
}
package oop.demo05;
//学生 is 人：派生类 子类
//子类继承了父类，就会拥有父类的所有方法
public class Student extends Person {
    private String name = "lanyangyang";
    
    public void print() {
        System.out.println("Student");
    }
    public void test1() {
        this.print(); //当前类里的print：输出Student
        super.print(); //父类Person里的print方法：输出Person
    }
    
    public void test(String name) {
        System.out.println(name); //调用test()方法传递的参数name：懒洋洋
        System.out.println(this.name); //this.name:当前student类的name：lanyangyang
        System.out.println(super.name); //super.name：父类person的属性name：lyy
    }
}
package oop.demo05;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("懒洋洋");
        student.test1();
}}
  • 注意点：
  1. 当父类的属性或方法为private时，子类将无法继承。
  2. 当父类有一个无参构造器时，子类中会默认先调用父类的再调用自身的。例如
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }
}
public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造 super();且当调用父类构造器时必须放在子类构造器前面
        System.out.println("Student无参执行了");
    }
}
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

  • 方法重写
  1. 需要有继承关系，子类重写父类的方法
  2. 方法名和参数列表必须相同
  3. 修饰符：范围可以扩大 不能缩小 public>protected>default>private
  4. 抛出的异常：范围可以被缩小但不能扩大： ClassNotFoundException ---> Exception(大)
  5. 子类的方法和父类的方法必须要一致，方法体不同
  • 为什么要重写：
  1. 父类的功能子类不一定需要或者不一定满足。
  • 示例
//重写是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B->test()");
    }
}
public class A extends B{
    @Override  //注解：重写
    public void test() {
        System.out.println("A->test()");
    }
}
public class Application {
    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用只跟左边定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {
        A a = new A();
        a.test();  //A->test()
        //父类的引用指向了子类
        B b = new A(); //子类重写了父类方法，非静态
        b.test();  //A->test()
    }
}

六、多态

  1. 动态编译：类型 可扩展性
  • 同一方法可以根据发送对象的不同而采用多种不同的行为方式。
  • 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）
  • 通过多态，可以使父类使用子类重写的方法，补充扩展的功能。
  • 多态存在的条件
  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象 Father father = new Son()；
  4. 注意：

        ①多态是方法的多态，属性没有多态性

        ②父类和子类：有联系 否则出现类型转换异常 ClassCastException

        ③static方法：属于类 不属于实例

        ④final：常量 无法重写

        ⑤private：私有，无法重写

public class Person {
    public void run(){
        System.out.println("run");
    };
}
public class Student extends Person {
    public void run(){  //子类重写父类方法
        System.out.println("son");
    }
    public void eat(){  //子类独有的方法
        System.out.println("eat");
    }
}
public class Application {
    public static void main(String[] args) {
       //一个对象的实际类型是确定的 new Student() new Person()
        //可以指向的引用类型不确定
        //student 子类，能调用的方法都是自己的方法或者是继承父类的方法
        Student s1 = new Student();
        //Person 父类型，可以指向子类 但是不能调用子类独有的方法
        Person s2 = new Student(); //父类的引用指向子类

        s2.run(); //子类重写父类方法，执行了子类的方法
        s1.run();
        //对象执行有哪些方法，主要看左边的类型 父类无法调用子类方法，除非向下转型
        ((Student) s2).eat();
    }
}
  1. instanceof

        ①判断一个对象是什么类型

  • x instanceof y 能不能编译通过取决于x与y是否存在线性父子关系
  • 能否编译看引用类型（左边），运行结果true/false看实际类型（右边）
public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object类>Person类>Student类
        //Object>Person>Teacher
        Object object =  new Student();
        //instanceof 判断一个变量所指向的实例是否是指定类型，或者是该指定类型的子类
        //判断object指向的Student实例是否为Student类型或者Student的子类
        System.out.println(object instanceof Student); //true
        //判断object指向的Student实例是否为Person类型或者Person的子类
        System.out.println(object instanceof Person);//true
        //判断object指向的Student实例是否为Object类型或者Object的子类
        System.out.println(object instanceof Object);//true
        //判断object指向的Student实例是否为Teacher类型或者Teacher的子类
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String); //false
        System.out.println("================================================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//      System.out.println(person instanceof String); //person类与String类同级，编译报错
        System.out.println("===============================================");
        Student student = new Student();
        System.out.println(student instanceof Student); //true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//      System.out.println(student instanceof Teacher);//Student类与Teacher类同级，编译报错
//      System.out.println(student instanceof String); //编译报错

②类型转换

  • 子类转换为父类：向上转换，转换后可能会丢失子类自身的方法
  • 父类转换为子类：向下转换，需要强制转换。
public class Person {
    public void run(){
        System.out.println("run");
    };
}
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}
public class Application {
    public static void main(String[] args) {
        //类型之间的转换：高转低需要强制转换 父->子
        //高                    低
        Person person = new Student();
        ((Student) person).go();  //父类调用子类方法需要强制转换为子类

        Student student = new Student();
        Person person1 = student; //子类student转换为父类person1
//      person1.go(); //无法调用子类的方法，丢失了student自身的方法
    }

七、抽象类

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

八、接口

  • 普通类：只有具体实现
  • 抽象类：具体实现和规范（抽象方法）都有
  • 接口：只有规范，自己无法写方法
  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。
  • 接口的本质是契约，就像法律一样，制定后大家都遵守。
public interface UserService {
    //接口中的所有定义都是抽象的 接口都需要有实现类
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
//类通过implement实现接口 需要重写接口的方法
//接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {
    }

    @Override
    public void add(String name) {
    }

    @Override
    public void delete(String name) {
    }

    @Override
    public void update(String name) {
    }

    @Override
    public void query(String name) {
    }
}
  • 接口的作用：
    1. 起约束作用
    2. 在接口中定义一些方法，可以让不同的类实现
    3. 接口中默认所有方法都是public abstract；所有属性都是public static final
    4. 接口不能被实例化，接口中没有构造方法
    5. implements可以实现多个接口，多继承
    6. 一个类implements接口之后，必须重写接口中的方法
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 3419
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
java面向对象详解
weixin_50073630的博客
10-07 3599
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面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
JAVA面向对象
JINGJID的博客
03-25 5191
一、类与对象的创建 1.使用new关键字创建对象 Person person = new Person("Jingjing"); 二、构造器详解 一个类即使什么也不写，也会存在一个构造方法 即便前面的类是空的，仍然可以使用new方法创建一个对象 1.无参构造器和有参构造器 2.快捷方法 alt + insert :生成有参构造 alt +insert +seleteNone(弹出的中间）：生成无参构造 ...
Java面向对象浅谈
编程界明世隐的博客
12-06 5299
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象基础
weixin_60719453的博客
10-13 9045
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java面向对象详解
无简介
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 面向对象思想
weixin_60808029的博客
10-29 1686
一、浅谈Java面向对象三大特征：封装、继承、多态 对象，是具体存在现实中的事物，比如人，比如手机。 那么如果将对象用代码表示出来呢？首先我们要知道我们表示的是什么？我们表示的是人 二、面向对象的抽象、接口特征 参考博客有： 接口和抽象类的区别---相信你看完不会再混淆了_不悔的青春-CSDN博客_接口与抽象类的区别 ...
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
JAVA面向对象程序设计(期末考试试题及答案).zip
06-05
这个压缩包文件"JAVA面向对象程序设计(期末考试试题及答案).zip"包含了学习和复习Java OOP的关键资源，包括一份详细的资源说明文档和期末考试试题及答案的PDF。 资源说明.docx可能涵盖了学习Java OOP的基础概念、...
JAVA面向对象程序设计(期末考试试题及答案).pdf
03-28
Java面向对象程序设计是编程领域中的核心概念，它基于面向对象的编程思想，将现实世界中的实体抽象为类，通过类来创建对象，实现代码的复用和模块化。在这个期末考试试题中，我们看到了一系列关于Java编程的问题，...
使用Spring Boot和Spring Security构建安全的RESTful API
intwei的博客
05-17 717
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
上集：一个前端的血泪复仇记 —— 静态部署的胜利
最新发布
十步杀一人-千里不留行
05-17 1210
在《上集：一个前端的血泪复仇记 —— 静态部署的胜利》中，作者分享了在部署一个前后端分离的小项目时遇到的挑战和解决方案。项目后端使用Spring Boot，前端使用Next.js。在部署过程中，前端静态资源的处理成为主要难题。作者通过将Next.js生成的静态文件直接放入Spring Boot的static目录，简化了部署流程。然而，Spring Security的默认配置阻止了对这些静态资源的访问，导致403错误。通过调整SecurityConfig和WebConfig，作者成功解决了这一问题。此外，前端
WEB安全--Java安全--CC1利用链
m0_74800552的博客
05-14 1523
CC1利用链的原理与构建方式
HashSet
weixin_51718998的博客
05-15 857
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
JAVA面向对象基础选择题及解析
"这是一份JAVA面向对象编程的考试题库，包含50道选择题和部分简答题，旨在测试和提升对JAVA面向对象概念的理解和应用能力。试题涵盖类的声明、方法、继承、多态等核心概念，以及访问修饰符、抽象类和方法、构造器等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值