Java学习笔记——面向对象编程(OOP)

最新推荐文章于 2026-05-04 09:34:50 发布
原创 最新推荐文章于 2026-05-04 09:34:50 发布 · 1.4k 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Java学习笔记

当前文章被收录于：

Java学习笔记
25 篇文章 2 人学习

Java学习笔记

订阅专栏 查看详情

面向对象编程(OOP) Object Oriented Programming

面向对象的特点:封装 继承 多态 (抽象)

介绍

什么是类
 具有相同特点(属性)和行为(动作)的集合的总称.
 人类
 植物类
 手机类
什么是对象
 是某一类的具体体现 实例
 将类的抽象概念具体化.
 人类的对象: 张三,特朗普,…
  植物类的对象 : 路边的梧桐,杨树
  手机类的对象 : 正在使用的手机
什么是属性
 是一类事物的特点/特征.
 人类的属性/特征 : 肤色,年龄,身高,体重…
 植物类的属性 : 树干,树叶,树根,花,果实
 手机的属性 : 价格,重量,颜色,形状
什么是方法
 一类事物都可以进行的动作/行为.
 人类的动作 : 吃饭睡觉打豆豆
 植物的动作 : 开花,结果,光合作用
 手机的动作 : 打电话,发短信

以学生类为例

编写类

Student.java文件代表学生类
 类中有属性和方法
学生类:
 属性 : 姓名 年龄 学号 学校…
 方法 : 学习 吃饭 睡觉

属性的写法:
  [访问修饰符] 数据类型 变量名;
  []内的代码,可写可不写

[访问修饰符] 返回值类型 方法名([参数1],[参数2],…){
  方法内的执行语句;
   …
}
访问修饰符 : 控制访问权限
返回值类型 : 该方法执行后返回的结果的数据类型（基本数据类型/引用数据类型 ）
      void : 空,方法执行后不返回任何数据
      …
  如果方法需要返回数据,
    1) 那就需要在返回值类型处写上返回数据的数据类型
    2) 在方法体的最后使用 return 值;的格式将值明确显示返回.
方法名 : 见名知意,驼峰原则
() 参数列表 :

  1. 形式参数 : 该方法执行可能用到的数据
  2. 形式参数的写法: 数据类型 变量名;
  3. 列表内可以写多个参数,或者不写
  4. 当方法参数列表有参数时,在调用时(让方法执行时)就必须给方法的参数赋值

{} 方法体
执行语句 : 该方法真正的功能体现 

package com.zhiyou100.oop;

public class Student {
	
	public String name;
	public int age;
	public String stuNo;
	String schoolName;
	
	public String study(String book,String pen) {
		System.out.println("在学习"+book);
		String name = "张三";
//		return "李四";
		return name;
	}
	
	void eat() {
		System.out.println("吃");
	}
	
	void sleep () {
		System.out.println("睡觉");
	}
	
}

对象的创建使用

通过类 创建对象 <==> 实例化
类名 对象名 = new 类名();
数据类型 变量名 = 值;
对象属性取值:
 数据类型 变量名 = 对象名.属性名;

对象属性赋值:
 对象名.属性名 = 值;

调用对象的方法

  1. 方法有参数,调用时必须传入实参;实参与形参的个数,顺序,数据类型要保持
  2. 方法没有参数,不能给参数
  3. 方法无返回值,一定不能接收返回值
  4. 方法有返回值,可以接收,也可以不接收
     A : 无返回值
       A1 无返回值无参
         对象名.方法名();
       A2 无返回值有参数
         对象名.方法名(值1,值2,…);
      B : 有返回值
       B1 有返回值无参
         [数据类型 变量名 = ]对象名.方法名();
       B2 有返回值有参数
         [数据类型 变量名 = ]对象名.方法名(值1,值2,…);

扩展：
一个类可以创建多个对象，并且每个对象多有自己的属性和方法

package com.zhiyou100.oop;

public class TestOOP {

	public static void main(String[] args) {
	
		// 创建对象
		Student stu1 = new Student();
		System.out.println(stu1);
		// 获得属性值 
		String name = stu1.name;
		int age = stu1.age;
		String stuNo = stu1.stuNo;
		String schoolName = stu1.schoolName;
		System.out.println("name = "+name);
		System.out.println("age = "+age);
		System.out.println("stuNo = "+stuNo);
		System.out.println("schoolName = "+schoolName);
		// 属性赋值
		stu1.name = "张三";
		stu1.age = 18;
		stu1.schoolName = "北京大学";
		stu1.stuNo = "100001";
		System.out.println("name = "+stu1.name);
		System.out.println("age = "+stu1.age);
		System.out.println("stuNo = "+stu1.stuNo);
		System.out.println("schoolName = "+stu1.schoolName);
		System.out.println("----------分割线---------");
		// A1 无返回值无参
		stu1.eat();
		// A2 无返回值有参数
		stu1.sleep("地");
		// B1 有返回值无参
		String result1 = stu1.playGame();
		System.out.println("结果 : "+result1);
		// B2 有返回值有参数
		String result2 = stu1.study("<java从入门到精通>", "黑笔");
		System.out.println("谁在学习 ? : " + result2);
		
	}
	
}

对象在内存的图示

在这里插入图片描述

两个引用指向一个对象

public class TestOOP3 {

	public static void main(String[] args) {
		/*
		 * 两个引用指向一个对象
		 * s1 是对象名,也是变量,也可以叫做引用
		 * s1引用的是内存中堆中的对象的地址值
		 * Student s2 = s1;
		 * 将引用赋值给s2.
		 * s1 和 s2 操作的是内存中的同一个对象
		 */
		Student s1 = new Student();
		Student s2 = s1;
		s1.name = "刘备";
		System.out.println(s2.name);
	};

}

在这里插入图片描述
方法的参数列表是类名时,该如何调用 ?
调用时,传入该类型的对象

完整的内存图

在这里插入图片描述

局部变量和成员变量

不同点
成员变量: 成员属性/全局变量/全局属性
  位置 : 类中,方法外
  在内存的位置 : 在堆内存
  生命周期 : 随着对象创建在堆中出现,随着对象被垃圾回收(GC)而消失
  初始值 : 随着创建对象,赋默认值
局部变量:
 位置: 方法参数列表中,或者方法体内
 在内存的位置 : 在栈内存
 生命周期 : 随着方法进栈而出现,方法执行完弹栈而消失
 初始值 : 在使用前必须给定值.
使用时的注意事项
当方法局部变量与成员变量重名时,
方法内使用时 “就近原则”,默认使用方法自己的局部变量
如果重名时,想要继续使用成员变量.要使用this指代
this.属性 指代成员变量
this就是当前调用该方法的对象

访问控制符修饰类

  1. 访问修饰符都可以修饰属性/成员变量
  2. 访问修饰符都可以修饰方法
  3. 访问修饰符又叫访问控制符/权限控制符
  4. 作用就是: 控制被修饰的属性或者方法在被别处(包括当前类或者其他类中)的访问权限.
    在这里插入图片描述

封装

封装的概念

把客观事物封装成抽象的类，并且类可以把自己的属性和方法只让可信的类或者对象进行操作，对不可信的类或者对象隐藏，这样的过程叫做封装。
封装的分类

对属性的封装

将属性设置为private(私有)，限制其只能在类的内部使用；提供set、get方法，set方法给属性赋值，get方法获得属性值。
setter getter 的方法名写法：setXxx、getXxx，Xxx 是类的属性首字母大写，访问修饰符不可以是private。

对方法的封装

对于方法的封装，将外部可以访问方法设置为public,将外部不能访问的方法设置为private
构造方法
构造方法/构造函数/构造器/constructor
作用 :
 创建对象,属性赋值
 new 构造方法();
语法格式 :
 访问修饰符 类名() {
 }
特点:

  1. 任何一个类中都默认隐式存在无参构造方法
  2. 构造方法没有返回值类型,连void都没有
  3. 构造方法的方法名是当前类的类名,首字母大写
  4. 在程序中显示写出任意一个构造方法.那么隐式的不再提供.

继承

一个新类从现有的类派生，这样的过程叫做继承
那么在继承的过程中，新类被称为子类，现有的类被称为父类，子类将会继承父类的属性和行为。
继承的语法
[修饰符] class 子类类名 extends 父类类名{子类类体部分}
子类的扩展
子类除了可以拥有父类非私有的属性和方法外，也可以扩展自己的属性和方法
使用

  1. Java中的继承是单继承，也就是一个类只能有一个父类。
  2. 如果一个类没有显式的继承某一个类，那么它有一个默认的父类是java.lang.Object类
  3. Java继承了父类非私有的成员变量和方法，但是请注意：子类是无法继承父类的构造方法的
  4. 子类可以使用父类的属性和方法,也可以使用租父类属性和方法 --> 多层次继承

在继承中成员变量的访问
1 当子类中没有该成员变量时,那么调用的就是父类的成员变量
2 当子类与父类有重名的成员变量时,默认访问的是子类自己的属性
但是一般情况时,子类不会有与父类重名的属性,因为继承就是为了使用父类的属性和方法

在继承中成员方法的访问
1 当子类中没有该方法时,那么调用的就是父类的方法
2 当子类有与父类重名的方法时 ——》方法的重写(@Override)
当子类重写了父类方法后,在调用时,调用的就是子类自己的方法

在继承中构造方法

  1. 构造方法不能继承,也不能被重写.更不能被对象调用.
  2. 在继承中,子类的构造方法会在构造方法第一行隐式调用父类无参构造. super();
  3. 如果现式写出调用父类构造方法的代码,必须写在第一行.
  4. 默认是调用父类无参的,也可以使用super(参数)调用父类有参数的构造方法
    在这里插入图片描述

多态

概念

什么是多态
 多态顾名思义即为多种形态的意思
Java中多态的含义
 发送消息给某个对象，让这个对象自行决定采用哪种行为响应这个消息
 子类对象的引用赋值给父类引用变量来实现动态的方法调用
 属性没有多态性,方法有多态性
Java中形成多态的前提
 继承
 重写
 父类引用指向子类对象

父类无法调用子类特有的方法
想要调用子类特有的方法,需要由子类自己的对象调用
向下转型: 父类转成子类
父类由哪个子类向上转型而成,那就只能向下转型成哪个子类. 而不是随便转变成任意子类.
a instanceof Dog： a变量如果是Dog类的对象,就返回true

抽象

1 抽象方法没有方法体
2 抽象方法还需要由abstract修饰
3 抽象方法必须定义在抽象类中
4 抽象类需要abstract修饰
5 抽象类不一定有抽象方法
6 抽象类也可以拥有正常的方法
7 属性不能被abstract修饰
8 抽象类可以有构造方法,但是不能创建对象
9 抽象类还是类
10 抽象类不能创建对象
11但是可以使用多态特性

继承抽象类
子类继承抽象类，必须重写父类的全部抽象方法，否则，就必须将子类也定义成抽象类

接口

接口相当于一种规范,约束

含义

各个小组的开发工作是并行的。在很多时候，对于不同小组的程序员来说，清楚地说明各自的软件如何相互作用，并就此达成统一“约定”是很重要的。这种情况下，每一小组都可以在对其他小组怎么编写代码一无所知的情况下，就能编写自己的代码，并且各自小组编写的代码能很好的协同工作。接口就是这样的“约定”。

在Java中接口不仅仅是程序开发过程中“约定”，更是更加抽象化的抽象类.
接口就是让你知道它在做什么，而无需知道它们怎么做；接口更深层的理解是：使定义（规范和约束）和实现（具体的代码逻辑）分离，它是沟通（交互）的中介物（具体实现）的抽象化。
接口即是设计：在设计层面，接口可以避免我们陷入对细节的过多思考，可以让我们站在一个更高的视角对系统做更好的评估，比如系统的交互设计是否合理，功能是否缺失，是否具备可行性，是否过于复杂等等。接口即是约定：在编码层面，接口可以明确的告诉开发人员如何使用（接口的语义，需要什么作为输入，会有什么输出），而开发人员只需要根据这些约定去实现具体的功能代码即可。统一类的共同行为：接口用来统一类的共通行为，当不同的类需要进行信息共享时，是不需要特别去创建类间的关系。举例来说，一个人（Human）及一只鹦鹉（Parrot）都会吹口哨（whistle），然而 Human 及 Parrot 不应该为 Whistler 的子类，最好的做法是令他们为 Animal 的子类，而他们可以使用 Whistler 的接口进行沟通。

接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找不到更好的词来表示，但是我们要明确一点就是，接口本身就不是类.

特点

1 接口文件是interface修饰,接口不是类
2 接口中的成员变量默认都被public final static
3 接口中不存在正常带方法体的方法,默认都是抽象方法,都默认被public abstract修饰在jdk8后可以使用default
4 接口中没有构造方法,不能创建对象

实现

  • 类 实现 接口,可以多实现,多个接口用,隔开
  • 类 继承 类,是单继承
  • 接口 继承 接口,且可以多继承,多个,接口逗号隔开
  • 类实现接口,要重写全部的抽象方法
  • 如果不重写或者没有全部重写,那么子类要定义成抽象类
    类可以在实现接口的同时,继承其他类–>写法是先 extends 后 implements


static关键字的作用与用法

static 在可用来修饰属性、方法。

常用方式：
static：main方法固定搭配（规定）

public static void main(String[] args){}

static特点

  1. 可以修饰属性,方法,在内存中只有一份
  2. 修饰的属性叫做类属性 该属性属于当前字节码文件(xx.class),被当前类创建出的所有对象共享,同理还有类方法
  3. 凡是被static修饰的属性和方法,会随着类加载而初始化
     类属性比对象属性先在内存出现,类属性可以不通过对象调用
     类名.静态属性;
     类名.静态方法();

注意：

  1. 静态方法只能调用静态的属性和方法 --> 静态只能调用静态
  2. 非静态方法既可以非静态属性和方法,也可以调用静态的属性和方法–> 非静态什么都可以调用
  3. 静态方法中不能使用this

说明：

  1. static变量：按照是否静态的对类成员变量进行分类：一种是被static修饰的变量，叫静态变量（类变量）；另一种是没有被static修饰的变量，叫实例变量。
     区别:
      a、对于静态变量在内存中只会一次拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中优先加载完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
      b、对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
  2. static代码块：static代码块是类加载时，初始化自动执行的，其优先级仅次于静态变量。如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
  3. static方法：static方法可以直接通过类名调用，任何的实例也都可以调用，因此static方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(也就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。tatic方法只能访问static的变量和方法，因为非static的变量和方法是需要创建一个对象实例才能访问的，而static的变量/方法不需要创建任何对象。

提示：
static的数据或方法，属于整个类的而不是属于某个对象的，是不会和类的任何对象实例联系到一起。所以子类和父类之间可以存在同名的static方法名，这里不涉及重载。所以不能把任何方法体内的变量声明为static。

this与super

在这里插入图片描述

重写（Override）与重载（Override）

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

方法重写的规则

  1. 参数列表必须完全与被重写方法的相同； 返回类型必须完全与被重写方法的返回类型相同；
  2. 访问权限不能比父类中被重写的方法的访问权限更高。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
  3. 父类的成员方法只能被它的子类重写。 声明为final的方法不能被重写。 声明为static的方法不能被重写，但是能够被再次声明。
  4. 如果一个方法不能被继承，那么该方法不能被重写。
  5. 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
  6. 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
  7. 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
  8. 构造方法不能被重写。 如果不能继承一个方法，则不能重写这个方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
只能重载构造函数

方法重载的规则

  1. 被重载的方法必须改变参数列表；
  2. 被重载的方法可以改变返回类型；
  3. 被重载的方法可以改变访问修饰符；
  4. 被重载的方法可以声明新的或更广的检查异常；
  5. 方法能够在同一个类中或者在一个子类中被重载
    在这里插入图片描述

final关键字:

	 * 1 修饰变量
	 * 	  变量不再是变量而是常量.必须赋初始值且值不可再改变.
	 * 2 修饰方法
	 * 	 final修饰的方法不能被重写
	 * 3 修饰类
	 * 	finale修饰类,类不能被继承
Java学习-方法
weixin_46051964的博客
05-21 429
一、方法的内存原理 有以下代码 package com.zwcode; public class MethodDemo01 { public static void main(String[] args) { study(); } public static void eat() { System.out.println("吃饭"); } public static void sleep() { System
java面向对象
m0_64509193的博客
12-25 381
1.类和对象的相关概念 1.类：是一组相关的属性和行为的集合。是一个抽象的概念。 对象：是该类事物的具体表现形式。具体存在的个体。 举例： 学生：类 班长：对象 2.类和对象的关系 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象 类只有一个，而对象可以有很多个 不同的对象之间属性可能会各不相同 类中定义了什么属性和方法，对象中就有什么属性和方法 2.类的定义 2.1 类的定义格式 Java中的类是通过class关键字来定义的，其语法格式如...
Java笔试题大全（附带答案）
热门推荐
web13618542420的博客
03-26 1万+
一、单选题 1.下列哪一种叙述是正确的（D） A．abstract修饰符可修饰字段、方法和类 B． 抽象方法的body部分必须用一对大括号{ }包住 C． 声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 2.如下代码 public class Test { public int aMethod() { static int i = 0; i++; return i; } public static void main (String args[]) { Test test = new Test
C++之继承
ZZY5707的博客
10-18 298
那在继承体系中,如果出现这种情况,即子类和父类中有同名成员,它有一个专属的称谓,叫作隐藏或者重定义.子类和父类中有同名成员,子类成员将屏蔽对父类同名成员的直接访问(默认访问到的是子类的那一个),这种情况叫隐藏,也叫重定义.(在子类成员函数中,可以使用 基类基类成员 显示访问)如果是出现同名的成员函数呢？子类和父类有同名成员，构成隐藏。但是这两个函数的函数名确实相同，但是参数不同啊，那这不是函数重载的一种情况吗。那这里到底是函数重载还是隐藏啊？函数重载是有前提的,函数重载要求在同一个作用域里面。
java-learning：26. 面向对象2 学生类
如云漂泊的博客
08-17 518
1. 定义学生类 package day06.demo01; /* 定义一个类，用来模拟“学生”事物。其中就有两个组成部分： 属性（是什么）： 姓名 年龄 行为（能做什么）： 吃饭 睡觉 学习 对应的Java的类当中： 成员变量（属性）： String name; int age; 成员方法（行为）： public void eat(); public void sleep(); public void study.
关于java中面向对象编程（OOP）的学习笔记
chb47100的博客
11-02 198
面向对象编程 面向对象思想 方法回顾与加深 对象的创建分析 面向对象三大特性 抽象类和接口 内部类与OOP实战 面向过程 & 面向对象 面向过程思想 步骤清晰简单 面对过程适合处理一些简单的问题 面向对象思想 物以类聚，分类的思考模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索 面向对象适合处理复杂的问题，适合处理多人协作的问题。 对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思
Java 学习笔记（三）面向对象编程（OOP)
芒果冰沙的博客
10-03 262
面向对象编程（OOP) **面向对象：**把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式 **类：**属性+方法; 面向对象编程本质：以类的方法组织代码，以对象的形式（封装）数据； 一、面向对象特性 封装 继承 多态 二、类与对象的关系 类是一种抽象的数据类型，它是对某一类事物整体的描述/定义，但是并不代表某一个具体的事物; 类是同一种事物的统称，是一个抽象的概念； 对象是对类的一个具体描述，是一个客观的实体； 对象是抽象概念的具体实例化；
小滴课堂-学习笔记：（6）Java 面向对象编程OOP
dev666的博客
12-30 493
愿景："让编程不再难学，让技术与生活更加有趣" 更多架构课程请访问 xdclass.net 目录 第1集 什么是面向对象对象编程OOP 第2集 Java面向对象的中的构造函数和封装 第3集 Java面向对象核心关键字this讲解 第4集 Java面向对象编程之继承 第5集 Java面向对象编程之继承的super关键词 第6集 Java面向对象编程之抽象 第7集 Java面向对象编程之接口 第8集 Java面向对象编程之InstanceOf关键词和多态 第9集 本章课程作业练习题..
Java面向对象编程（OOP）学习笔记：从基础到进阶
最新发布
qq_55515447的博客
05-04 191
静态代码块、构造代码块和构造方法的执行顺序：静态优先于对象，父类优先于子类1.静态代码块：类加载时执行（最早执行，且只执行一次）。2.构造代码块：创建对象时执行（每次 new 都执行，在构造方法之前）。3.构造方法：创建对象时最后执行。具体伪代码演示// 1. 父类静态代码块static {System.out.println("1. 父类静态代码块");// 3. 父类构造代码块System.out.println("3. 父类构造代码块");// 4. 父类构造方法。
JAVA学习笔记-面向对象编程（OOP）
weixin_30480075的博客
11-07 70
面向对象思想的本质： 　　以类的方式组织代码，以对象的方式（封装）数据。 对象：是具体的事物。 类：是对对象的的抽象（抽象 抽出象的部分） 先有具体的对象，然后抽象各个对象之间象的部分，归纳出类，通过类再认识其他对象。 转载于:https://www.cnblogs.com/iamAnonymous/p/6039116.html...
循序渐进学Java笔记（Chapter08_面向对象编程[中级部分]）
ZZHow Blog
08-05 821
本文介绍了Java面向对象编程的中级内容，重点讲解了IDEA开发工具的使用、包的概念、访问修饰符规则以及封装技术。主要内容包括：IDEA常用快捷键和模板功能；包的本质和命名规范；四种访问修饰符的权限级别；封装的概念、实现步骤和快速入门案例。文章还提供了多个代码示例，如HelloIDEA、冒泡排序实现、包的导入演示和封装案例等，展示了如何通过封装保护数据安全并进行合理验证。这些内容为Java中级开发者提供了实用的开发工具使用技巧和面向对象编程的核心概念。 写于2024//01/29
2021-06-02 Java基础学习笔记
hanshzh的博客
06-05 158
Java基础学习笔记 If选择结构 语法结构： 1. if单选择结构 if(布尔表达式){ //如果布尔表达式为true将执行的语句 } 2. if双选择结构 if(布尔表达式){ //如果布尔表达式的值为true }else{ //如果布尔表达式的值为false } 3. if多选择结构 if(布尔表达式1){ //如果布尔表达式1的值为true执行代码 }else if(布尔表达式2){ //如果布尔表达式2的值为true执行代码 }else if(布尔表达式3){ //如果 布尔表达式3的值为t
JAVA-面向对象编程 (OOP)
a787769407的博客
07-17 2417
封装通过将数据和操作数据的方法封装在一个类中，并使用访问控制修饰符来控制访问权限，提供了一种保护数据和实现细节的机制。这样不仅提高了代码的安全性和可维护性，还增强了代码的可读性和重用性。继承是面向对象编程中的一个重要概念，它允许子类继承父类的属性和方法，从而实现代码的重用和扩展。通过继承，可以创建层次结构的类，将通用功能放在父类中，特殊功能放在子类中。继承不仅提高了代码的可维护性和可扩展性，还为多态性的实现提供了基础。
OOP面向对象编程之java打飞机游戏
wblearn的博客
07-24 9481
#写在前面 继上一篇OOP面向对象编程之俄罗斯方块项目实现过程 ,OOP面向对象编程之java打飞机游戏，其实写的很简单，也很容易理解，并且注释写的很清楚了，还有问题，自己私下去补课学习(顺便做50个深蹲，嘿嘿，平时干嘛去了)，看图：     #完整代码     敌飞机   package com.tarena.fly; import java.util.Random;
什么是面向对象编程？OOP 深入解释
qq_37116560的博客
05-11 5151
面向对象编程 (OOP) 是一种基本的编程范式，几乎每个开发人员都在其职业生涯的某个阶段使用过。OOP 是用于软件开发的最流行的编程范例，并且在大多数程序员的教育生涯中被作为标准编码方式教授。 另一种流行的编程范式是函数式编程，但我们现在不讨论它。 今天，我们将分解使程序面向对象的基础知识，以便您可以开始在您的算法、项目和面试中使用这种范式。 现在，让我们深入了解这些 OOP 概念和教程！ ...
Java面向对象编程（OOP）
weidl001的博客
06-13 1283
类是现实世界中一类事物的抽象，是Java中构造对象的模板。类的定义包括类名，属性（成员变量）和方法。// 属性// 构造方法// 方法概念描述示例类对象的模板或蓝图对象类的实例属性类的成员变量方法类的成员函数构造方法用于创建对象的特定方法概念描述示例封装将数据和方法保护在类内部，仅允许通过指定方法访问抽象从现实世界中抽取出共同特性，忽略具体细节抽象方法没有具体实现的方法，仅声明存在概念描述示例继承子类继承父类的属性和方法方法重载。
Java 面向对象编程（OOP）的四大特征
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！✨
07-06 6349
在Java编程中，面向对象编程（OOP）是一个核心概念。OOP的四大基本特征分别是：抽象、继承、封装和多态。本文将详细介绍这四个特征。
面向对象编程（OOP）
AlbenXie的博客
08-10 1403
明白它是 “为解决复杂系统问题而生” 的工具；能将现实世界的实体和关系映射到类、对象、继承等概念；在实践中体会 “何时用 OOP”“如何用好 OOP”（而非生搬硬套概念）。当你写代码时，不再刻意思考 “我要封装一下”，而是自然地用对象组织逻辑，就说明真正理解了 OOP。
Java的OOP(面向对象编程)总结，有这一篇足矣
weixin_56069070的博客
03-11 3661
前言：OOP是Java语言中重要组成部分，其中面向对象编程是Java中核心编程思想，今天就将OOP知识进行总结 目录 一、思维导图 二、面对对象 1.首先要了解面对对象是什么? 2.具体说法 3.面对对象三大基本特征 三、对象与类 1.对象 2.类 四、方法 1.方法定义 2.有参构造和无参构造 五、重载、构造、重写 1.重载和重写的区别 2.构造 3.方法重写的规则 4.方法重写与方法重载的区别 六、this、static、单例模式、instanceof 1.this
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值