JAVA_OOP详细概述（含代码）

最新推荐文章于 2024-05-24 18:14:28 发布
最新推荐文章于 2024-05-24 18:14:28 发布
阅读量1.9k 收藏 11
点赞数 2
分类专栏： java基础面向对象 文章标签： 封装 继承 多态 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48868978/article/details/118938732
版权

一、面向对象的思想

1.1面向对象思想的概论

概论

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面 向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。

特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。 面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

1.2类和对象

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物。

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性 和行为。

对象与类的关系

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

1.3类的定义

属性：事物的状态信息。

行为：事物能够做什么。

成员变量：对应事物的属性

成员方法：对应事物的行为

public class ClassName {
//成员变量
//成员方法
}

定义类：就是定义类的成员，包括成员变量和成员方法。

成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。

成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细 讲解。

类的定义格式举例：
public class Student {
//成员变量
String name；//姓名
int age；//年龄
    //成员方法
//学习的方法
publicvoid study() {
System.out.println("好好学习，天天向上");
}
//吃饭的方法
publicvoid eat() {
System.out.println("学习饿了要吃饭");
}
}

1.4对象的使用

//创建对象
类名 对象名 = new 类名();
//使用对象中的成员
//对象名.成员变量;
//对象名.成员方法();

对象使用格式的举列：

public class Test01_Student {
public static void main(String[] args) {
//创建对象格式：类名 对象名 = new 类名();
    Student s = new Student();
    System.out.println("s:"+s); //cn.itcast.Student@100363
    //直接输出成员变量值
    System.out.println("姓名："+s.name); //null
    System.out.println("年龄："+s.age); //0
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //给成员变量赋值
    s.name = "赵丽颖";
    s.age = 18;
    //再次输出成员变量的值
    System.out.println("姓名："+s.name); //赵丽颖
    System.out.println("年龄："+s.age); //18
    System.out.println("‐‐‐‐‐‐‐‐‐‐");
    //调用成员方法
    s.study(); // "好好学习，天天向上"
    s.eat(); // "学习饿了要吃饭"
}

1.5成员变量和局部变量的区别

public class Car{
    	String color;	//成员变量
    public void dribe(){
        int speed = 80;	//局部变量
        System.out.print("")
    }
    
}
在类中的位置不同

成员变量：类中，方法外

局部变量：方法中或者方法声明上(形式参数）

作用范围不一样

成员变量：类中

局部变量：方法中

初始化值的不同

成员变量：有默认值

局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同

成员变量：堆内存

局部变量：栈内存

生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

二、封装

2.1封装的概念

概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的 方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要某个属性，提供公共方法对其访问。

2.2封装的步骤
  1. 使用 private 关键字来修饰成员变量。
  2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
  3. idea中使用Alt+Insert快捷键
  4. eclipse中右键Set and get 方法
private的含义
  1. private是一个权限修饰符，代表最小权限。
  2. 可以修饰成员变量和成员方法。
  3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式
private 数据类型 变量名;
public class Student {
private String name;
private int age;
}

//封装之后
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
2.3this的使用

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

this.成员变量
2.4构造方法
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
  1. 如果你不提供构造方法，系统会给出无参数构造方法。
  2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
  3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

三、 继承

3.1定义

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

好处

  1. 提高代码的复用性。

  2. 类与类之间产生了关系，是多态的前提。

class 父类 {
...
}
class 子类 extends 父类 {
...
}

3.2成员变量不重名

class Fu {
// Fu中的成员变量。
	int num = 5;
}


class Zi extends Fu {
    // Zi中的成员变量
int num2 = 6;
// Zi中的成员方法
public void show() {
// 访问父类中的num，
    System.out.println("Fu num="+num); // 继承而来，所以直接访问。
    // 访问子类中的num2
    System.out.println("Zi num2="+num2);
    }
}
class ExtendDemo02 {
public static void main(String[] args) {
// 创建子类对象
    Zi z = new Zi();
    // 调用子类中的show方法
    z.show();
    }
}
演示结果：
Fu num = 5
Zi num2 = 6

3.2成员变量重名

class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
// 访问父类中的num
System.out.println("Fu num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + num);
}
}
class ExtendsDemo03 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰 父类成员变量，类似于之前学过的 this 。

使用格式

super.父类成员变量名

class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
}
演示结果：
Fu num = 5
Zi num = 6
成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对 应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码如下：

成员方法重名（重写）

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。 方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效 果，也称为重写或者复写。声明不变，重新实现。

3.3注意事项

  1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

  2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

3.4构造方法继承后的特点

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。 2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构 造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代 码如下：

3.5super 和 this

super和this的含义

super ：代表父类的存储空间标识(可以理解为父亲的引用)。

this ：代表当前对象的引用(谁调用就代表谁)。

四、多态

定义

多态： 是指同一行为，具有多个不同表现形式。

  1. 继承或者实现【二选一】

  2. 方法的重写【意义体现：不重写，无意义】

  3. 父类引用指向子类对象【格式体现】

多态的体现

父类类型 变量名 = new 子类对象；

Fu f = new Zi();
f.method();

多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。

如：

//定义父类
public abstract class Animal {
	public abstract void eat();
}
//定义子类
class Cat extends Animal {
    public void eat() {
    	System.out.println("吃鱼");
		}
	}
class Dog extends Animal {
    public void eat() {
    	System.out.println("吃骨头");
    }
}

//定义测试类
public class Test {
    public static void main(String[] args) {
    // 多态形式，创建对象
    Cat c = new Cat();
    Dog d = new Dog();
    // 调用showCatEat
    showCatEat(c);
    // 调用showDogEat
        showDogEat(d);
    /*
    以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
    而执行效果一致
    */
    showAnimalEat(c);
    showAnimalEat(d);
   	 }
    public static void showCatEat (Cat c){
        c.eat();
        }
    public static void showDogEat (Dog d){
        d.eat();
        }
    public static void showAnimalEat (Animal a){
        a.eat();
        }
}

类型转换

向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。 当父类引用指向一个子类对象时，便是向上转型。

父类类型 变量名 = new 子类类型();

向下转型

父类类型向子类类型向下转换的过程，这个过程是强制的。父类类型向子类类型向下转换的过程，这个过程是强制的。

子类类型 变量名 = (子类类型) 父类变量名

转型的异常 instanceof

public class Test {
    public static void main(String[] args) {
    // 向上转型
    Animal a = new Cat();
    a.eat(); // 调用的是 Cat 的 eat
    // 向下转型
    if (a instanceof Cat){
    Cat c = (Cat)a;
    c.catchMouse(); // 调用的是 Cat 的 catchMouse
    } else if (a instanceof Dog){
    Dog d = (Dog)a;
    d.watchHouse(); // 调用的是 Dog 的 watchHouse
   		 }
    }
}
/变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

子类类型 变量名 = (子类类型) 父类变量名

转型的异常 instanceof

public class Test {
    public static void main(String[] args) {
    // 向上转型
    Animal a = new Cat();
    a.eat(); // 调用的是 Cat 的 eat
    // 向下转型
    if (a instanceof Cat){
    Cat c = (Cat)a;
    c.catchMouse(); // 调用的是 Cat 的 catchMouse
    } else if (a instanceof Dog){
    Dog d = (Dog)a;
    d.watchHouse(); // 调用的是 Dog 的 watchHouse
   		 }
    }
}
/变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
码农486
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础 -- (3)什么是OOP
fuxiaosu的博客
09-21 427
OOP 文章目录OOP简述 : 简述 : 在了解OOP之前首先我们先了解一下POP 什么是POP呐? --> 面向过程 面向过程 : 面向过程是我们早期的一个编程概念,过程类似于函数,只能执行 面向过程的执行步骤 : - 把完成某一个需求的 所有步骤 从头到尾 逐步实现 ...
Java详细讲解OOP面向对象
github_67177094的博客
06-20 2289
类中的static代码块的特点：常见的异常
【JVM】底层实现（一）：浅谈 OOP-Klass 对象模型
A minor
10-22 2545
当我们在写 Java 代码的时候，我们会面对着无数个接口，类，对象和方法。但我们有木有想过，Java 中的这些对象、类和方法，在 HotSpot JVM 中的结构又是怎么样呢？HotSpot JVM 底层都是 C++ 实现的，那么 Java 的对象模型与 C++ 对象模型之间又有什么关系呢？今天就来分析一下 HotSpot JVM 中的对象模型：oop-klass model。 1.OOP-Klass 模型概述 HotSpot JVM 并没有根据 Java 实例对象直接通过虚拟机映射到新建的 C++ 对象，
Java基础---OOP
最新发布
B6665X的博客
05-24 763
类的定义：在Java中，使用关键字class来定义一个类。类定义通常包括类名、成员变量（属性）、方法（行为）和构造函数。类名命名规则：类名通常使用大驼峰式命名法（CamelCase），并且首字母大写。示例// 成员变量// 方法// 启动汽车的代码// 构造函数**接口（Interface）**是Java中的一个引用类型，它是一组抽象方法的集合，这些方法没有具体的实现。接口可以被类实现，实现接口的类必须提供接口中所有方法的具体实现。定义接口：使用interface关键字定义接口。实现接口。
Java中OOP的理解
qq_50864729的博客
05-15 2115
目录 1. 什么是OOP 2. 面向对象的三大特性： 2.1 封装 2.2 继承 2.3 多态 3. OOP的优缺点 3.1 优点 3.2 缺点 4. OOP设计模式六大原则 1. 什么是OOP 什么是OOP，Object Oriented(面向) Programming，即面向对象编程。很早很早以前的编程是面向过程的，我们提到的面向对象编程的优点，一般是和面向过程编程POP(procedure oriented Programming) 对比的。 2. 面向对象的三大特性： 2.
java面向对象9经典程序
mike_jun的博客
12-17 1616
转载自：http://blog.csdn.net/u010793590/article/details/28898923 1 Hello world例子 [java]view plaincopy packageExample;//定义自己的包名 publicclassExample1
JAVA视频OOP-IO流技术讲解视频
11-20
javaOOP必看精华视频资料，1：主要介绍IO流中的递归 2：文件输出导出数据与文件输入导入数据的构造方法 3：递归求阶乘代码实现及内存讲解 4：不死神兔问题案例 5：IO流基类概述及一个简单的需求分析 6：...
Java和面向对象概述.pptx
11-21
面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的软件开发范式，它以对象为核心，强调数据和操作数据的方法相结合。Java语言是面向对象编程的代表之一，广泛应用于各种软件开发领域。 在软件开发...
Java OOP.mmap
04-02
一、Java 概述 1. Java体系 2. 常用的DOS命令 3. JDK、JRE、跨平台、Java平台 4. Java代码的编写执行过程 5. 注释 6. 关键字、标识符 7. Java中的数据类型 8. Java中的常量 二、变量和运算符 1. 变量和...
java基础教程.zip_Java编程_Java__Java编程_Java_
08-09
以下是对教程内容的详细概述： 1. **Java简介**：Java是由Sun Microsystems（现为Oracle Corporation）于1995年发布的，它的设计目标是“一次编写，到处运行”。Java运行在Java虚拟机（JVM）上，确保代码能在多种...
Java概述_3 视频
03-21
在Java概述中，我们首先会接触到Java的历史和设计原则。Java的诞生是为了克服C++的一些局限性，尤其是内存管理方面的复杂性和跨平台移植的困难。其主要设计原则包括简单性、面向对象、健壮性、安全性、可移植性、高...
JVM的内存分配原理
guoyuguang0的专栏
09-20 1371
分配前的加载 当使用new关键字创建一个JAVA对象时，JVM首先会检查这个New指令的参数是否在常量池中定位到一个类的符号引用，然后检查与这个符号引用相对应的类是否已经成功经历过加载、解析和初始化等步骤。当类完成装载步骤之后，就已经完全可以确定出创建对象实例时所需要的内存空间大小，接下来JVM就会对其进行内存分配，以存储所生成的对象实例。 分配内存 基于分代的概念，Java的堆区还可以划分为
jvm源码分析之oop-klass对象模型
lzf的博客
08-01 1944
概述 HotSpot是基于c++实现，而c++是一门面向对象的语言，本身具备面向对象基本特征，所以Java中的对象表示，最简单的做法是为每个Java类生成一个c++类与之对应。 但HotSpot JVM并没有这么做，而是设计了一个OOP-Klass Model。这里的 OOP 指的是 Ordinary Object Pointer （普通对象指针），它用来表示对象的实例信息，看起来像个指针实际...
JVM markOopDesc
jxluoix的专栏
07-17 849
/*  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.  *  * This code is free software; you can redi...
聊聊Java面向对象(OOP)
m0_55337678的博客
03-23 518
聊聊Java面向对象(OOP)
面向对象编程
jie的博客
09-16 236
面向对象编程类和实例访问限制继承和多态获取对象信息实例属性和类属性 面向对象的程序设计：把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。 面向过程的程序设计：把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。 在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的
python面向对象OOP（代码实例）
Programmer_Mt的博客
02-05 551
封装 import datetime class Book: count = 0 #初始化执行 def __init__(self,title,price = 0.0,publisher = '',pubdate = datetime.date.today()):#初始化器,构造函数初始化内成员用的 self.title = title, ...
Java_30_面向对象编程（OOP）的本质_类的方式组织代码_对象的方式组织（封装）数据
pmcasp的博客
03-22 614
对象：是具体的事物类：是对对象的抽象（抽象 抽出象的部分）以类为模板生成对象OOP:以类的方式组织代码，以对象的方式组织（封装）数据先有具体的对象，然后抽象各个对象之间象的部分，归纳出通过类在认识其他对象。public class testObject {//类-组织代码 String name; public void study(){ System.out.println(name); } ...
JAVA--OOP（封装、继承、多态）
月夜-星空
03-01 9634
一、封装    封装要点是对XXX的概括描述，从实物到抽象。    例如：【私家车----》汽车car；   载客车----》大巴bus；   拉货车----》卡车truck】对现实中的实物做了封装,抽象成具体类    拓展：【汽车----》车；大巴----》车；卡车----》车】对具体类做了封装，抽象成抽象类/接口；二、继承    子类和父类的关系体现了java的继承特性；    父类有的公共方...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值