Java -- 面向对象（一）

最新推荐文章于 2024-02-04 13:00:38 发布
原创 最新推荐文章于 2024-02-04 13:00:38 发布 · 482 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #面向对象编程

本文深入讲解Java面向对象编程，涵盖类与对象的概念、创建与使用，以及封装、继承、多态等核心特性。通过实例演示如何利用面向对象思维简化复杂问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述
终于到了java的关键地方了，面向对象。不好理解，但是必须要理解。
现实世界中，随处可见的一种事物就是对象，对象是存在的实体，如人类、书桌、计算机、高楼大厦等。面向对象实质上就是对现实世界的对象进行建模操作。

一、面向对象概述

概念

所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。
我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）

  • 面向过程强调的是过程，例如：
    1、打开冰箱 2、把大象放进去 3、关上冰箱
  • 面向对象强调结果，例如：
    饿了，去平台点餐，这个动作就是面向对象。你没有去市场买菜洗菜做饭。。。只要有app就可以了。
特征：
  • 封装
  • 继承
  • 多态

二、类和对象

1、概念
  • 类：
    ① Java语言最基本单位就是类，类似于类型；
    ② 类是一类事物的抽象；
    ③ 可以理解为模板或者设计图纸；
  • 对象：
    每个对象具有三个特点：对象的状态，对象的行为和对象的标识；
    ① 对象的状态用来描述对象的基本特征。
    ② 对象的行为用来描述对象的功能。
    ③ 对象的标识是指对象在内存中都有一个唯一的地址用来和其他对象区分开来。
    ④ 类是一类事物的抽象，对象是具体的实现。
2、两者的关系
  • 计算机语言是用来描述现实世界的，通过属性+行为
  • 通过类来描述事物，把事物的属性当做成员变量，把行为当做成员方法。

分析手机事物：

  • 属性：颜色，尺寸，品牌，价格。。。
  • 方法：打电话，发短信，听音乐。。。。
  • 类：手机类，抽取相同的属性和行为
  • 对象：可以按照模板生产很多个手机，比如1号手机对象，包含特有的成员变量和成员方法
3、类和对象的创建和使用

3.1 单个类和对象的创建与使用

通过class关键字来创建类，通过new关键字创建对象

package cn.tedu.hello.day06;

public class Test_Object1 {

	public static void main(String[] args) {
		// 4、创建对象测试
		//new Phone();//匿名对象
		//5、通过new关键字创建对象.引用类型的变量p就保存了一个地址值
		Phone phone = new Phone();
		//p对象能调用模板里面的属性和行为吗？
		phone.call();
		phone.message();
		phone.music();
		
		//6、设置属性的值
		phone.color = "red";
		phone.size = 7;
		phone.pinpai = "小米";
		phone.price = 2999.0;
		
		//7、打印属性的值
		System.out.println(phone.color);
		System.out.println(phone.size);
		System.out.println(phone.pinpai);
		System.out.println(phone.price);
		
	}
}

//1、通过class关键字创建类，用来描事物：属性+行为
class Phone {
	//2、属性：颜色、尺寸、品牌、价格 -- 用成员变量/成员属性 描述
	String color;
	int size;
	String pinpai;
	double price;
	
	//3、行为：打电话、发短信、听音乐 -- 用成员方法 描述
	//方法修饰符 方法返回值 方法名（参数列表）{方法体}
	public void call() {
		System.out.println("正在通话中...");
	}
	public void message() {
		System.out.println("正在发送...");
	}
	public void music() {
		System.out.println("正在播放...");
	}
}

3.2 对象在内存中的存储
在这里插入图片描述
重点关注堆和栈：

  1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放；
  2. 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放；
  3. 每个堆内存的元素都有地址值；
  4. 对象中的属性都是有默认值的；

3.3 单一对象内存图
在这里插入图片描述
执行过程：

  1. 在栈内存，开辟空间存放局部变量/引用变量p；
  2. 在栈内存中，开辟空间，存放对象，完成初始化；
  3. 给堆内存中元素，分配一个唯一的标志------地址值，交给p去保存；
  4. p.color = "red;p.size = 7;等就去堆内存中找唯一的地址值，找到Phone对象，并对其属性进行修改赋值。
  5. p.call();等方法，就去堆内存中找唯一的地址值，找到Phone对象，执行Phone对象的方法。

3.4 多个类和对象的创建与使用

创建Car类

package cn.tedu.hello.day07;

//1、创建汽车类
class Car {
	//成员变量/成员属性 -- 特征
	String color;
	String pinpai;
	String model;
	double price;
	
	//成员方法 -- 行为
	public void run() {
		System.out.println("正在启动...");
	}
	public void fly() {
		System.out.println("正在飞...");
	}
}

测试多个对象

package cn.tedu.hello.day07;

//这个类用来测试多个对象
public class Test_Object {
	public static void main(String[] args) {
		//2、创建汽车对象测试(有名对象)
		Car car = new Car();
		//匿名对象也可以，但是匿名对象一次只能做一件事
//		new Car().run();
//		new Car().fly();
		
		//调用模板里面的功能
		car.run();
		car.fly();
		
		//设置默认值
		car.color = "white";
		car.model = "H6";
		car.pinpai = "哈弗";
		car.price = 180000;
		
		System.err.println(car.color);
		System.err.println(car.model);
		System.err.println(car.pinpai);
		System.err.println(car.price);
		System.out.println();
		
		//创建多个对象
		Car car2 = new Car();
		//设置默认值
		car.color = "black";
		car.model = "H9";
		car.pinpai = "哈弗";
		car.price = 200000;
		
		System.err.println("c2="+car.color);
		System.err.println("c2="+car.model);
		System.err.println("c2="+car.pinpai);
		System.err.println("c2="+car.price);
		System.out.println();
		
		//把car2的属性传递给car3
		//把car2记录着的内存地址，交给car3保存，都是引用类型的变量，所以都存地址
		//使用的和car2是一个属性
		Car car3 = car2;
		System.err.println("c3="+car.color);
		System.err.println("c3="+car.model);
		System.err.println("c3="+car.pinpai);
		System.err.println("c3="+car.price);
	}
}

3.5 多个对象内存图

在这里插入图片描述

三、封装

1、概述

封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。

封装的好处：

  • 提高安全性
  • 提高重用性
2、private关键字

是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。
想要修改只能，对外提供公共的，get和set方法。

3、练习封装

仔细阅读代码，慢慢领会面向对象的好处；

package cn.tedu.privatedemo;

public class Test_Student {
	//测试封装
	public static void main(String[] args) {
		//创建学生对象
		Student student = new Student();
		
		//调用学生类的方法
		//student.study();//私有方法，除了本类，外界无法访问
		student.game();//调用game方法的同时，间接调用study方法
		
//		student.age = 20;
		student.setAge(13);//私有变量的设置，set方法
		student.name = "Daniel";
		student.subject = "数学";
		
		System.out.println(student.getAge());//用get方法获取
		System.out.println(student.name);
		System.out.println(student.subject);
	}
}

学生类

package cn.tedu.privatedemo;

//创建一个学生类：属性+行为
class Student {
	//修饰符不写，那就是默认default，但是写上就报错
	//	default int age;
	
	//1、通过private关键字，实现封装
	//2、如果被private私有化，只能在本类中访问，其他类看不到，也用不了
	private int age;
	
//	int age;
	String name;
	String subject;
	
	//创建get/set方法，给外界提供全局的访问点
	//set设置值，get获取值
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	//创建方法
	//3、private可以修饰成员变量或者成员方法
	//private void study() {}
	
//	public void study() {
//		System.out.println("正在学习...");
//	}
	private void study() {
		System.out.println("正在学习...");
	}
	public void game() {
		study();//4、study()方法被私有化，外界无法直接访问,但是可以间接访问
		System.out.println("正在吃鸡..");
	}
}
知识拓展：

1、创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情
  1. 把Person.class文件加载进内存
  2. 在栈内存中，开辟空间，存放变量p
  3. 在堆内存中，开辟空间，存放Person对象
  4. 对成员变量进行默认的初始化
  5. 对成员变量进行显示初始化
  6. 执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
  7. 堆内存完成
  8. 把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值

2、匿名对象

没有名字的对象，是对象的简化表示形式。

使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）

Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。

也可以写成：

new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法

四、构造方法

1、概念
  • 构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。
  • 对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。
  • 当类实例化一个对象时会自动调用构造方法。
  • 构造方法和其他方法一样也可以重载。
2、创建形式
  • 可以创建无参的，也可以创建有参的
修饰符 类名([参数列表]){
	方法体;
}
3、构造方法创建对象

仔细阅读代码，重点分析笔记混合在代码中，身临其境更有感觉；
① 创建测试构造方法的类；

package cn.tedu.constructor;

//这个类用来测试构造方法
public class Test_Cons {
	public static void main(String[] args) {
		//创建person对象
		//3、无参创建对象，底层会自动调用--无参的构造方法
		Person p = new Person();
		
		//5、触发含参构造
		Person p2 = new Person("Daniel");	
	}
}

② 创建一个Person类；

package cn.tedu.constructor;

//创建person类
public class Person {
	//1、提供构造方法：修饰符 类名([参数列表]){方法体}
	//2、默认会存在无参构造方法，前提是没有提供含参构造。
	//如果类中提供了含参构造，无参构造就真没了
	public Person() {
		System.out.println("无参构造方法");
	}
	//4、构造方法的重载形式:方法名相同+参数列表不同
	public Person(String name) {
		System.out.println("含参构造方法" + name);
	}
}
4、构造方法赋值

① 创建测试方法

package cn.tedu.constructor;

//这个类用来测试构造方法
public class Test_Animal {
	public static void main(String[] args) {
		//3、创建对象测试
		Animal a = new Animal();//自动触发无参构造
		Animal a2 = new Animal("憨憨");//触发含参构造
	}
}

② 创建Animal类

package cn.tedu.constructor;

public class Animal {
	
	//创建成员变量
	String name ;
	
	//提供构造方法
	//修饰符 类名([参数列表]){}
	public Animal() {}//1、空着也得摆好，方便外界创建对象
	
	//2、重载形式的构造方法
	public Animal(String n) {//n是形参，也是局部变量
		//n是局部变量
		System.out.println("含参构造" + n);
		//4、拿着局部变量 n 给成员变量 name 赋值
		name = n;
		System.out.println(name);//憨憨
	}
}

切记：无参构造函数就算是摆着好看，也要摆在代码里面

五、构造代码块和局部代码块

1、构造代码块
  • 位置：在类里，方法外的代码块
  • 作用：提取构造方法的共性
  • 优先级：构造代码块 > 构造方法
2、局部代码块
  • 位置：在方法里面的代码块
  • 作用：控制变量的作用范围，出了括号就失效
    ☆☆：变量的范围越小越好，成员变量会有线程安全问题
  • 优先级：局部代码块顺序执行

总结：执行顺序：构造代码块是最优先的，局部代码块顺序执行

3、测试类

① 创建测试类

package cn.tedu.block;

//测试代码块的使用
public class Test_Block {
	public static void main(String[] args) {
		//1、在创建对象时做了两件事：执行了代码块 + 构造方法
		//2、一定会先触发对应的构造方法。
		//3、如果有构造代码块，执行顺序：构造代码块 > 构造方法 > 局部代码块
		Teacher teacher = new Teacher();//无参
		Teacher teacher2 = new Teacher("Daniel");//含参
		
		//6、触发局部代码块
		teacher.show();
	}
}

② 创建Teacher类

package cn.tedu.block;

//创建类
public class Teacher {
	//构造代码块
	//1、位置：如果在类里方法外，是构造代码块
	//4、通常构造代码块用于 提取 构造方法的共性，提高了代码的复用性
	String country;
	{
		//提取了共性,只不过，变量的作用范围只在代码块中有效
		country = "中国人";
		System.out.println("构造代码块");
	}
	
	//无参构造
	public Teacher() {
		System.out.println("无参构造方法" + country);
	}
	
	//含参构造
	public Teacher(String name) {
		System.out.println("重载的构造方法" + name + country);
	}
	
	//5、局部代码块：位置是在方法里，作用是控制变量的作用范围
	public void show() {
		{
			int sum = 10;
			System.out.println("局部代码块" + sum);
		}
		//只能在自己的变量范围内使用
		//System.out.println(sum);
	}
}

问题拓展：

1、构造代码块什么时候触发？-------- 在创建对象的时候触发
2、局部代码块什么时候触发？-------- 在方法被调用时

在这里插入图片描述

【下篇预告】

  • this关键字
  • 继承的使用
  • super关键字
  • 方法的重写
  • 继承中的用法
  • …
jmu-Java-03面向对象基础-04-形状-继承 PTA
qq_43427314的博客
10-31 3775
jmu-Java-03面向对象基础-04-形状-继承 PTA题目本题描述：思考分析答案 题目 前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。 本题描述： 1.定义抽象类Shape 属性：不可变静态常量double PI，值为3.14， 抽象方法:public double getPerimeter(),public double getArea() 2.Rectangle与Circle类均继承自Shape类。 Rectangle类
5.2 jmu-Java-04面向对象进阶--02-接口-Comparator (5 分)
wzy992981933的博客
04-22 1205
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age 2 编写Comparator类 编写
JAVA 对象的行为 总结
weixin_34198762的博客
04-02 151
    对象的行为 1. 断点调试 a：定位（设置断点）  b：启动调试  c：单步执行  观察变量（F5单步执行   F6单步跳过）d：修改2 static  静态   静态成员，为类的所有对象共享   在静态方法中，只能直接调用静态成员，不能直接调用非静态成员   在成员方法中，可以直接调用静态成员与非静态成员  静态成员的调用： 类名打点方式调用3 方法重载：  在一个类中有两个及两...
定义一个计算机类：属性：品牌；价格；颜色； 方法：（1）编程的功能 （2）上网的功能 实例化两个对象：“lenovo”；“hasee”
weixin_40678639的博客
10-23 5189
public class Computer{ public static void main(String[]args){ Com lenovo = new Com(); lenovo.brand="lenovo"; lenovo.price=4500; lenovo.color="白色"; //调用方法 lenovo.program(); lenovo.shangWang
Java基础Day07
Riven_x的博客
10-18 1607
学习目标 1.能够知道类和对象的关系 2.能够完成类的定义及使用 3.能够知道对象在内存中的初始化过程 4.能够知道局部变量和成员变量的区别 5.能够知道private关键字的特点 6.能够知道this关键字的作用 7.能够知道构造方法的格式和注意事项 8.能够完成一个标准类代码的编写及测试 今天的内容可能会有点抽象，但希望大家能够理解面向对象，Java语言是全面象对象的。 想要思维导图笔记的也...
python程序设计题库及答案,python程序设计题库网站
最新发布
chatgpt002的博客
02-04 909
创建派生类Student，继承Person类，新增实例属性major（专业），新增实例方法setMajor()用来给实例属性major赋值，重写基类的实例方法show()输出所有实例属性的值。16. 编写程序，创建基类Shape，其成员包括实例属性color，实例方法getColor()用于获取实例属性color的值，实例方法setColor()用来设置实例属性color的值；5. 编写程序，输入一个18位的身份证号码，从中提取出生日期，并以“出生日期是*年*月*日”样的格式输出。
java基础3
qq_52701502的博客
05-01 935
封装构造方法this关键字static关键字再谈变量所谓的封装，就是利用private关键字去修饰属性或者方法 ，被private关键字去修饰的属性或者方法只能在本类中被访问。构造方法是一个特殊的方法，主要特殊点如下构造方法的名字与类的名字一致它不声明返回值类型。（与声明为void不同）不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位。
Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
12-28
pta题目java的继承覆盖综合题源码，全部内容为自己原创，能够运行但是有些代码可能写的不是很精简，这个摘要也太长了吧，凑不够字数啊
Java-语言与面向对象程序设计PPT.ppt
10-31
Java-语言与面向对象程序设计PPT.ppt
07-JAVA-面向对象
06-02
JAVA面向对象思维导图，便捷整理思路，面向对象的概念、创建对象、成员变量和局部变量、访问对象中的属性和方法、构造方法以及重载
78： 部署Elasticsearch 、 Elasticsearch 、 kibana 、 总结和答疑
weixin_46575696的博客
11-17 600
CASE Top NSD ARCHITECTURE DAY01 案例1：安装Elasticsearch 案例2：部署Elasticsearch集群 案例3：安装Elasticsearch插件 ...
20210809学习
qq_40151384的博客
08-09 614
day07复习总结 面向对象的特征: 继承 1. 使用extends 建立子类与父类的继承关系 2.子类继承父类相当于子类把父类的功能复制了一份,但注意,构造方法不能被继承. 3.继承后,子类可以使用父类所有非私有资源,私有资源不可用的原因是不可见 4.java只支持单继承,一个子类只能有一个父类,但是一个父类可以有多个子类 关键字 super super 可以在父类成员变量与子类成员变量同名时,用super,变量名的方式调用父类的成员变量 还可以通过super调用父类的构造方法,子类的构造方法首行默认存
1 Day06--面向对象1
abu1216的博客
11-28 461
1.1面向对象 1.1.1概念 所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。 我们经常说的面向对象的编程实现（OOP，Object Oriented Programming） l面向过程强调的是过程，例如： 1、打开冰箱2、把大象放进去3、关上冰箱 l面向对象强调结果，例如： 1、饿了，去平台点餐，这个动作就是面向对象。你没有去市场买菜洗菜做饭。。。只要有app...
Spring DI详解
热门推荐
qq_42603060的博客
01-23 1万+
1.IOC（DI）-控制反转（依赖注入） 所谓的IOC称之为控制反转，简单来说就是将对象 的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理,而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。而在创建对象的过程中Spring可以依据配置对象的属性进行设置，这个过程称之为依...
2021-10-12-------用户认证登录系统
qq_44494957的博客
10-13 2117
用户认证登录流程 设计表格 教师和学生 如果添加权限角色是可以的，从教师表格查询登录用户设置为教师角色，从学生表格查询的用户设置为学生角色 t_student（role=student） t_teacher（role=teacher） t_roles角色表格 扥 登录流程 最终效果：如果访问后台（增删改查的功能），不能是学生角色，需要时教师角色，如果是学生账号登录，不允许操作后台班级，专业，学生，教师的任何操作，学生账号只能通过首页教学中心查看自己的学科课程 如果实现这个效果，认证中，第一次访问生成用户信息
学生选课.sql
qifenzhicheng的博客
03-07 784
/* Navicat MySQL Data Transfer Source Server : mysql1 Source Server Version : 50505 Source Host : localhost:3306 Source Database : 学生选课 Target Server Type : MYSQL Target Server Version : 50505 File Encoding : 65001 Dat...
接口，类与接口的关系，接口与抽象类的区别
weixin_59606855的博客
07-17 933
接口 1 接口的概念 与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准. 2 接口格式 3 接口的特点: 通过interface关键字来定义接口 通过implements让子类来实现接口 接口中的方法全部都是抽象方法(JAVA8) 可以把接口理解成一个特殊的抽象类(但接口不是类!!!) 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法 接口突破了java单继承的局限性 接口.
配置target存储
weixin_34283445的博客
06-28 1111
一、基础概念块级别：提供块设备（磁盘）文件级别：提供共享文件夹DAS：直连式存储。本地磁盘NAS：网络附加存储。本质上就是共享文件夹SAN：存储区域网络。FC SAN：基于光纤的存储区域网络 二、配置iSCSI1、准备三台虚机vh01.tedu.cn 192.168.4.1 存储服务器Vh02.tedu.cn 192.168.4.2 mysql1Vh03.tedu.cn 192.168....
Java面向对象编程课程课件PPT
Java面向对象程序设计是计算机科学领域的重要概念之一，也是现代软件开发中最常用的编程范式。掌握面向对象设计的核心概念对学习Java语言以及进行高效软件开发至关重要。 首先，我们需要理解面向对象程序设计（OOP...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

经理，天台风好大

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值