面向对象——封装

最新推荐文章于 2024-11-02 09:11:41 发布
最新推荐文章于 2024-11-02 09:11:41 发布
阅读量749 收藏 1
点赞数 2
分类专栏： 学习的旅途 文章标签： java 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54588824/article/details/114088369
版权

突如其来的空闲时间真是让人不知所措，所以临时决定再写点什么东西。

面向对象（OOP）（Object Oriented Programming）是以对象为中心，把一项工程看做是由一个个对象组成，这些对象之间存在的关系构成了整个项目。可以说，这是一种更加符合我们习惯的思想，可以将复杂的事情简单化。
面向对象的三大基本特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）
这次先写写封装

封装

1、封装的好处

1.安全
2.隔离变化
3.操作简单
4.可重复使用

2、封装的原则

把隐藏的的隐藏起来，该暴露的暴露出来。

3、封装的入门

常规写法：用private修饰属性，为每个属性提供对应的get和set方法（偷懒小技巧：鼠标右键→Source→Generate Getters and Setters…）
（ps：private表示私有属性，public表示公有属性）

3.1、代码实例

public class Dog {
	private int age;// 私有属性
	private String name;
	// 提供公有的get/set方法
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	// 成员方法
	public void howl() {
		System.out.println("小狗在嚎叫");
	}
}

测试

public class DogTest {

	public static void main(String[] args) {
		Dog dog = new Dog();// 创建对象
		
		dog.setName("单身狗");// 调用公有方法，给成员变量赋值
		dog.setAge(21);
		
		String name = dog.getName();// 获取实例变量的值
		int age=dog.getAge();
		System.out.println(name);
		System.out.println(age);
		
		dog.howl();// 调用成员方法
	}
}

3.2、入门小结

1.封装可以隐藏该类一些功能的实现。在允许调用者通过事先实现的方法访问类的功能和数据的同时，限制对类中数据的不合理访问；
2.对数据进行检查，有利于保护对象信息的完整和合理性；
3.便于对代码的修改和维护，提高代码的可维护性。

4、this关键字

this表示当前对象或可理解为正在创建的对象。

4.1、this关键字与成员变量赋值

public class Dog {
	private int age;
	private String name;
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
}

4.2、this关键字与类中方法的互调

public class Dog {
	private int age;
	private String name;
	
	public void howl() {
		System.out.println("小狗在嚎叫");
		this.eat();
	}
	public void eat() {
		System.out.println("小狗在吃骨头");
	}
}

4.3、this关键字与构造方法

注意：this语句在调用其他构造函数时必须在该构造函数中处于第一条有效语句，一旦在它前面有任何有效语句，都会造成编译错误。

public class Employee {
	private String name;
	private int salary;
	/*
	 * 执行顺序：
	 * 		Employee()→Employee(String n)→Employee(String n,int s)
	 * 最终状态：
	 * 		name的值为Employee，salary的值为5000
	 */
	public Employee(String n,int s) {
		name = n;
		salary = s;
	}
	public Employee(String n) {
		this(n,5000);// 调用本类的构造函数Employee(String n,int s)
	}
	public Employee() {
		this("Employee");// 调用本类的构造函数Employee(String n)
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}	
}

public class Test2 {

	public static void main(String[] args) {
		Employee employee = new Employee();
		System.out.println(employee.getName());
		System.out.println(employee.getSalary());
	}
}

结果：
Employee
5000

5、构造函数

5.1、构造函数的作用

1.对对象的属性进行初始化或者进行初始化的工作；
2.与new一起使用来创建对象。

5.2、构造函数的特点

1.方法名与类名一致，且不提供任何数据类型的返回值；
2.没有返回值，可以只写一个return；
3.在一个类中如果没有显示任何构造器，系统会提供一个默认的无参构造器（正常情况下是隐藏起来的）；
4.在一个类中如果声明了任何构造器，系统就不会提供默认的无参构造器（这点要注意！！！）。

5.3、构造函数的实例

代码

public class Dog {
	private String name;
	private int age;
	public Dog() {
		super();
		System.out.println("这是无参构造函数");
	}
	public Dog(String name,int age) {
		System.out.println("这是有参构造函数");
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

执行

public class Test {

	public static void main(String[] args) {
		Dog dog1 = new Dog();// 无参构造函数
		dog1.setName("落花");
		dog1.setAge(2);
		System.out.println(dog1.getName());
		System.out.println(dog1.getAge());
		System.out.println("==========");
		Dog dog2 = new Dog("流水", 3);// 有参构造函数
		System.out.println(dog2.getName());
		System.out.println(dog2.getAge());
	}
}

结果

这是无参构造函数
落花
2
==========
这是有参构造函数
流水
3

温馨提示：为了您和您的程序代码的安全，请永远手动给出无参构造函数

5.4、构造函数的重载

在一个类中可以定义多个构造函数，这就是构造函数的重载。（ps：构造函数的重载在上面其实也出现过ヾ(≧▽≦*)o）

public class Employee {
	private String name;
	private int salary;
	
	public Employee() {
		name = null;
	}
	public Employee(String n,int s) {
		name = n;
		salary = s;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}	
}

public class Test2 {

	public static void main(String[] args) {
		Employee employee = new Employee();
		// 由于没有参数，所以调用 Employee()
		System.out.println(employee.getName());
		System.out.println(employee.getSalary());
		System.out.println("-----");
		Employee employee2 = new Employee("A",5000);
		// 由于参数是String、int，所以调用 Employee(String n,int s)
		System.out.println(employee2.getName());
		System.out.println(employee2.getSalary());
	}
}

6、static关键字

static主要用于修饰类的属性和方法，实现类的静态属性和静态方法的共享。

6.1、静态声明

1.静态属性
在普通属性的声明中，加上static关键字就是属性声明为静态属性。

public class Demo {
	public static int number = 2;
}

2.静态方法
在普通方法的声明中，加上static关键字就是方法声明为静态方法。

public class Demo {
	public static int sum(int x,int y) {
		return x+y;
	}
}

3.访问静态属性和静态方法
访问静态属性和静态方法时，不需要使用对象实例进行引用，只需要类名引用。

public class UseDemo {

	public static void main(String[] args) {
		System.out.println(Demo.number);
		int a = 10;
		int b = 5;
		System.out.println(Demo.sum(a, b));
	}
}
结果：
2
15

4.静态代码块
静态代码块随着类的初始化而初始化，只执行一次。

public class StaticDemo {
	// 静态代码块在加载类的字节码后立即执行，不需要创建对象实例
	static {
		System.out.println("static block 1");
	}
	static {
		System.out.println("static block 2");
	}
	// 通常使用static和final配对定义常量
	public static final double pi = 3.1415;
	public StaticDemo() {
		System.out.println("构造函数的调用");
	}
	
	public static void main(String[] args) {
		System.out.println("StaticDemo.pi："+StaticDemo.pi);
	}
}

6.2、静态与实例

静态属性和静态方法是属于类范围的，称为类属性或类方法。
实例属性和实例方法是属于对象范围的，称为实例属性或实例方法。
1.定义

public class StaticAndInstance {
	public StaticAndInstance(int id) {
		this.id = id;
	}
	
	private int id;
	public int getId() {
		return id;
	}

	public static final double pi = 3.1415;
	public static void testStatic() {
	}
}

2.存放位置
静态属性和静态方法：随着类的加载保存在方法区。
实例属性和实例方法：随着对象的建立存在于堆内存。

3.生命周期
实例变量和对象实例的生命周期是相同的。实例变量的内存空间技术在对象的内存空间中，是在JVM的堆中分配的。
静态变量和类的生命周期是相同的。通常将类加载到方法区后，知道JVM停止前，它都是一直存在的。

4.访问方式
静态属性的生存期不依赖于对象，可以在各个实例之间共享，其他的类不用实例化即可调用它们。

	public static void main(String[] args) {
		// 静态调用，不用创建相应的对象实例
		System.out.println(StaticAndInstance.pi);
		StaticAndInstance.testStatic();
		
		// 实例调用，一定要创建对象实例
		StaticAndInstance instance1 = new StaticAndInstance(1);
		System.out.println(instance1.getId());
	}

5.常见错误提示
实例方法可以访问实例变量和静态变量；
静态方法不能直接访问实例属性和实例方法；
在静态方法中创建对象后调用实例方法；
在静态方法中只能访问静态变量和静态方法；
只能在实例方法中使用this，静态方法中不能使用；

6.3、注意事项

1.在static方法中只能访问static属性和static方法，不能访问类的实例变量和成员方法；
2.static修饰的方法不能被改写或覆盖。因为静态方法是类方法，是属于类的，和对象无关；
3.static方法内部不能有this和super；
4.访问静态变量和方法：类名.静态成员。

好家伙，我后悔了，这临时决定写的博客差点把我人都写没了o((⊙﹏⊙))o.。

面向对象的封装
luomoxiaoyaoke的博客
06-23 3281
文章目录前言一、封装是什么？二、封装的概念三、封装的实例讲解总结 前言 封装是将一些基本的数据类型复合成一个自定义的类型，本文从数据角度和行为角度简单介绍下面向对象的封装。 一、封装是什么？ 面向对象有三大特征，分别是封装，继承，多态。封装是将一些基本的数据类型复合成一个自定义的类型。 二、封装的概念 1、封装 1、数据角度 概念： 将一些基本的数据类型复合成一个自定义的类型 优点： 1、建立数据与对象之间的关联 2、代码可读性强 2、行为角度 定义： 类外提供必
面向对象--封装
简之恨寒的博客
08-08 1195
数据隐藏通常指的就是封装。封装是 Java 面向对象的特点的表现，封装是一种信息隐蔽技术。也就是说，如果我们使用了封装技术的话，别人就只能用我们做出来的东西而看不见我们做的这个东西的内部结构了。2、import关键字：是用来引用包的，我们的类或者Java的开发类，都存放在不同包下，当我们要是用这个类时，就需要将这个类引入，使用import关键字进行引用。所谓的封装，其实很好理解，就是将代码通过包装的方式存放起来。既然是通过包装的方式，那么我们可以理解为将代码存放在一个容器当中，这个容器，我们称之为包。...
Java面对对象-封装
weixin_45906258的博客
11-05 495
一、面对对象-封装 （1）、封装介绍 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。 （2）、封装的优点 良好的封装能够减少耦合。 类内部的结构可以
Java面向对象的三大特征-封装（超详细）
最新发布
weixin_52176709的博客
11-02 1003
本文介绍了Java面向对象之前的类的成员之三构造器，还有面向对象基本特征之封装，最后讲了对象数组和增强for循环。
面向对象—封装
weixin_53854631的博客
01-13 296
今日学习总结： 封装 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。在面向对象程式设计 方法中，封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 既可以实现对客体属性的保护作用，又可以提高软件系统的可维护性 只要用户接口不改变，任何封装体内部的改变都不会对软件系统的其他部分造成影响封装隐藏实现细节，并对外提供了公共的访问方式 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问 要访问该类的代码和数据，必须通过严格的接口控制。 封
面向对象，封装
AHAI1078766113的博客
07-06 372
一．面向对象概念回顾 面向对象的概念：目前来说要有一个整体的意识 类：就是一个分类，类别，一般是描述现实中的事物. 例如：classPerson{} class Student{}等等 像我们写的PersonStudent自己写的类和java内库中的类性质是一样的（String Arrays Date） 字符串对象String 他其实就是一个类 对象：实例，实体，类的个体 ...
Java 面向对象——封装
qq_45259494的博客
04-13 2439
面向对象——封装1、类和对象1.1、什么是对象1.2、什么是类1.3、什么是对象的属性1.4、什么是对象的行为1.5、类和对象的关系1.6、类的定义1.7、对象的使用成员变量和局部变量2、封装2.1、private 关键字2.1、this 关键字2.3、封装2.31、封装概述2.32、封装原则2.33、封装的好处 1、类和对象 1.1、什么是对象 万物皆对象，客观存在的实物皆为对象 1.2、什么是类 类是对现实生活中的一类具有共同属性和行为的实物的抽象 类的特点： 1、类是对象的数据类型。 2、类是具有相同
c#面向对象——封装
03-12
c#面向对象——封装
C#面向对象——封装
云都小生
12-07 459
Author：云都小生权限修饰、 封装面向对象的三大特性之一，其中很重要的，就是要将数据封装在每个单元(C#、Java中是类)中，尽量不允许外部直接对数据进行操作，保护数据或者防止代码被无意破坏。class Student { private int id; public int Id { get { return id
大数据Java基础DAY8（面向对象——封装）
大数据
01-16 2081
封装 封装概述 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 好处： 隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。 封装原则： 将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。 ...
面向对象——封装、构造器的练习题（Java）
weixin_50669884的博客
02-19 784
题目： class Account{ private int id;//账号 private double balance;//金额 private double annuallnterestRate;//年利率 //构造器 public Account(int id,double balance,double annuallnterstRate) { this.id = id; this.balance = balance; this.annuallnterestRate =
面向对象（封装）
weixin_53026450的博客
03-03 156
什么叫面向对象：我们java开发人员其实每天都在和对象打交道，所以我们称之为面向对象编程。 面向对象的特点： 封装，继承，多态，抽象 封装其实就是包裹方法，对方法进行归类整理，对外提供get和set方法，其他类只能通过get和set对对象属性值进行操作。 对象：类是一个模板，不能直接使用，需要创建对象。 类名 对象名 = new 类名（）； 使用对象： 对象名.成员变量 对象名.方法（） ...
面向对象之封装
人丑就要多读书的博客
04-28 262
目录一 、引入二、 隐藏属性三 、开放接口3.1 隐藏数据属性3.2 隐藏方法属性四 、property（属性）装饰器 一 、引入 ​ 面向对象编程有三大特性：封装、继承、多态，其中最重要的一个特性就是封装。封装指的就是把数据与功能都整合到一起，听起来是不是很熟悉，没错，我们之前所说的”整合“二字其实就是封装的通俗说法。除此之外，针对封装到对象或者类中的属性，我们还可以严格控制对它们的访问，分两步实现：隐藏与开放接口 二、 隐藏属性 Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成
面向对象-封装
StandByMeQuan
10-27 468
JavaSE学习笔记第七天-面向对象之封装 什么是封装？ 将某些东西包装在一起，然后以新的完整形式呈现出来。 封装的目的和意义？ 提高安全，不能让外部随便调用和更改内部属性。 方便我们控制业务员逻辑。 如何实现封装？ 使用private修饰成员变量。然后在给这些成员变量根据相应的需求提供相应的public的set和get方法。 get和set方法的意义和书写形式？ 权限修饰......
面向对象 封装
the_first_step的专栏
02-02 2354
引自：http://blog.csdn.net/kangmiao89757/article/details/10656473  一、理解面向对象         面向对象和面向过程都是一种思想，就看自己怎么想了，面向对象是基于面向过程的。 面向对象的特点：         1. 是一种符合人们思考习惯的思想         2. 可以将复杂的事情简单化
面向对象封装
qq_41774065的博客
03-08 1274
一．面向对象概念回顾1. 面向对象的概念：目前来说要有一个整体的意识2. 类：就是一个分类，类别，一般是描述现实中的事物.例如：class Person{}  class Student{}等等像我们写的Person Student自己写的类和java内库中的类性质是一样的（String Arrays Date）字符串对象String 他其实就是一个类  3. 对象：实例，实体，类的个体目前我们创...
面向对象---封装
chao199512的博客
07-26 2142
封装 1.封装是面向对象编程的一大特点 2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中 3.外界使用类创建对象，然后让对象调用属性和方法 4.对象方法的细节都被封装在类的内部 下面通过几个实例让我们对封装有更深切的认识。   实例演练1： XX爱跑步 1.XX体重75.0公斤 2.XX每次跑步会减肥0.5公斤 3.XX每次吃东西体重会增加1公斤 """ cla...
JavaScript面向对象编程（一）：封装
陈林
12-29 1398
JavaScript面向对象编程（一）：封装 JavaScript面向对象编程：封装 JavaScript是一种基于对象的语言，遇到的所有东西几乎都是对象，但是，它又不是一种真正的面向对象（OOP）语言，因为它的语法中没有class（类）。 如果要把“属性”（property）和“方法”（method），封装成一个对象，甚至要从原型对象生成一个势力对象。 一丶生成实例化对象的原始模型 假...
Java面向对象：封装、继承与多态解析
"面向对象封装继承和多态.docx" 在Java编程语言中，面向对象编程（Object-Oriented Programming, OOP）是一种核心概念，它基于类和对象，以实现代码的模块化和复用性。Java的三大特性——继承、封装和多态，是OOP的...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值