面向对象--封装、继承、多态

最新推荐文章于 2024-03-27 11:46:38 发布
最新推荐文章于 2024-03-27 11:46:38 发布
阅读量302 收藏 2
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43251783/article/details/83386354
版权

1. 面向对象的概念

  • 面向对象：封装
    -类内部行为自己控制，别人无法干涉
    本身方法等 自身决定

  • 面向对象：继承
    子类复用父类的描述信息和行为
    父类/基类：哺乳动物类
    子类/派生类：人类

  • 面向对象：多态
    哺乳动物类：人类、马类
    人类和马类 鸣叫行为不一样，称为多态

2.定义类

  • 方法、变量小写开头。 类大写开头
  • 成员变量是：private； 成员方法是:public ； 不要加static
public class Person {
	//成员变量 一般是private
	private int age;
	private String name;
	// 成员方法  一般是public
	//设置年龄
	public void setAge(int value)
	{
		this.age=value;
	}
	
	//设置名字
	public void setName(String value)
	{
		this.name=value;
	}
	
	//读取名字+年龄
	public void sayHello()
	{
		System.out.println("我的名字是"+this.name+"，我的年龄是"+this.age);
	}
}

3.对象的创建和调用方法

定义类的变量，指向初始化的对象，调用方法

public class Main {

	public static void main(String[] args) {
		// 定义变量p 指向一个初始化对象
		Person p=new Person();
		//调用成员变量和成员方法
		p.setAge(30);
		p.setName("小伟");
		p.sayHello();
	}

}

4.对象之间是相互独立的

相同类的对象之间 或者不同类的对象之间都是相互独立的

public static void main(String[] args) {
		// 定义变量p 指向一个初始化对象
		Person p=new Person();
		//调用成员变量和成员方法
		p.setAge(30);
		p.setName("小伟");
		p.sayHello();
		
		//定义新对象。p和p1 这两个变量指向的对象互不影响
		Person p1=new Person();
		p1.setAge(33);
		p1.setName("林志颖");
		p1.sayHello();
		
		//重新调用p指向的对象的方法
		p.sayHello();

5.通俗方法讲变量和对象

1个变量只能指向一个对象
如果变量指向对象变了，那么之前所指向对象的关系删除

public class Main {

	public static void main(String[] args) {
		// 定义变量p 指向一个初始化对象
		Person p=new Person();
		//调用成员变量和成员方法
		p.setAge(30);
		p.setName("小伟");
		p.sayHello();
		
		//定义新对象。p和p1 这两个变量指向的对象互不影响
		Person p1=new Person();
		p1.setAge(33);
		p1.setName("林志颖");
		p1.sayHello();
		
		
		// p2 指向 p1变量所指向的对象
		Person p2=p1;
		p2.setAge(66);
		p2.setName("周润发");
		p2.sayHello();
		p1.sayHello();
	}

}

6 给方法传变量

传递给方法的参数变量本身是拷贝。
public class Main {

public static void main(String[] args) {
	// 定义变量p 指向一个初始化对象
	Person xiaowei=new Person();
	//调用成员变量和成员方法
	xiaowei.setAge(30);
	xiaowei.setName("小伟");
	xiaowei.sayHello();
	//调用方法，改变变量的值
	test(xiaowei);
	xiaowei.sayHello();
	
}

// 定义一个方法，注意是要加static 
static void test(Person p)
{
	p=new Person();
	p.setAge(888);
}

}

7成员变量和局部变量

必须初始化，对象初始化为null
NullPointerException --空指针

8 深入理解this

  • Person 类
package com.test;

public class Person {
	
	private int age;
	private String name;
	private int height;
	private String gender;
	
	public void setAge(int age)
	{
		this.age=age;
	}
	
	public int getAge()
	{
		return this.age;
	}
	
	public void setName(String name)
	{
		this.name=name;
	}
	
	public String getName()
	{
		return this.name;
	}
	
	public void setHeight(int height)
	{
		this.height=height;
	}
	
	public int getHeight()
	{
		return this.height;
	}

	public void setGender(String gender)
	{
		this.gender=gender;
	}
	
	public String getGender()
	{
		return this.gender;
	}
	
	
	public void  sayHello()
	{
		System.out.println("my name is "+this.name+",我的年龄是"+this.age+"，我的身高是"+this.height+",我的性别是"+this.gender);
	}
	
	public boolean isSamePeople(Person p)
	{
		return this.age==p.age&&this.name.equals(p.name)  
				&& this.height==p.height &&this.gender.equals(p.gender);
	}
}
  • main函数
package com.test;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1=new  Person();
		p1.setAge(18);
		p1.setGender("girl");
		p1.setHeight(175);
		p1.setName("xiaowei");
		p1.sayHello();
		
		
		Person p2=new  Person();
		p2.setAge(18);
		p2.setGender("girl");
		p2.setHeight(175);
		p2.setName("xiaowei");
		p2.sayHello();
		
		
		Person p3=new  Person();
		p3.setAge(38);
		p3.setGender("boy");
		p3.setHeight(159);
		p3.setName("zhangsan");
		p3.sayHello();
		
System.out.println(p1.isSamePeople(p2));
System.out.println(p2.isSamePeople(p3));



	}

}

9 private 和public

类中 成员变量一般用private 成员方法是public
成员变量的值设定或者取得一般用 set 和get public方法

10构造函数

  1. 构造函数 可以不定义，系统默认有一个无参构造函数。
  2. 方法名和类名一致，没有返回值
  3. 构造函数可在类中定义，public Person()
  4. 构造函数可以重载，多个构造函数，参数类型或者个数不一致
  5. 如果有有参构造函数，则类默认的无参构造函数不能用，除非新建无参构造函数
  6. 构造函数一般用来赋初始值
    构造函数：可以用来进行初始化值； get set 可以用来改变值。 不矛盾，可以配合使用
//定义类
public class Person {
	
	private int age;
	private String name;
	
	
	// 定义构造函数，与类名相同，无参数
	public Person()
	{
		System.out.println("定义构造函数");
		
	}
	
	// 定义构造函数1，与类名相同，有1个参数

	public Person(int age)
	{
		System.out.println("定义构造函数1");
		this.age=age;
	}
	
	// 定义构造函数2，与类名相同，有1个参数

		public Person(int age,String name)
		{
			System.out.println("定义构造函数2");
			this.age=age;
			this.name=name;
		}
	
	
	public void setAge(int age)
	{
		this.age=age;
	}
	
	public int getAge()
	{
		return this.age;
	}
	
	public void setName(String name)
	{
		this.name=name;
	}
	
	public String getName()
	{
		return this.name;
	}
	
	
	public void  sayHello()
	{
		System.out.println("my name is "+this.name+",我的年龄是"+this.age);
	}
	
	
}

//定义main函数
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1=new  Person();
		p1.sayHello();
		
		Person p2=new  Person(15);
		p2.sayHello();
		
		
		Person p3=new  Person(15,"zhangsan");
		p3.sayHello();
	
	}

}

11 JavaBean 规范

  1. 如果成员变量希望外界赋值，提供set方法
  2. 如果成员变量希望外界读取，提供get方法
  3. 类必须是公共类，最多只能有1个public类
  4. 必须有一个无参的构造函数
  5. 成员变量private
  6. boolean 类型成员变量 get方法 可以是is

12 对象和对象之间的关系

  • 示例
    Dog 类有性别和姓名
    Person类 有年龄，身高以及Dog类的对象
    Dog
public class Dog {

	private String name;
	private String sex;
	
	// 无参构造函数
	public Dog()
	{
		
	}
	
	//set 和get 成员变量
	public void setName(String name)
	{
		this.name=name;
	}
	
	public String getName()
	{
		return this.name;
	}

	// 利用Source自动生成 成员变量set 和get
	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
	
	public void sayhello()
	{
		System.out.println("i am one dog; my name is "+this.name+",my sex is "+this.sex);
	}
	
}

Person

package com.test;

public class Person {

	// 定义一个无参构造函数
	public Person() {

	}

	// 定义3个普通成员变量 和 1个Dog 类的变量
	private int age;
	private int height;
	private String name;
	private Dog pet;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//set和get类的变量
	public void setPet(Dog pet)
	{
		this.pet=pet;
	}

	public Dog getPet() {
		return this.pet;
	}
	
	public void sayhello()
	{
		if(this.pet==null)
			System.out.println("i am sorry");
		
		else
			System.out.println("my name is "+this.name+",我的身高是"+this.height+",我的年龄是"+this.age+
				"我的宠物名字是"+this.pet.getName()+"，我的宠物性别是"+this.pet.getSex());
	}

}

Main类

package com.test;

public class Main {

	public static void main(String[] args) {

		// 初始化人，最好是先初始化狗，为了避免空指针
		Person p1=new Person();
		p1.setAge(33);
		p1.setHeight(180);
		p1.sayhello();
		
		//初始化狗 并且赋值
		Dog d1=new Dog();
		d1.setName("旺财");
		d1.setSex("girl");
		p1.setPet(d1);
		d1.sayhello();
		p1.sayhello();
		

	}

}

13 包

  • 作用：
    不同类放在不同包下面，比较好区分
    重名类放在不同的包下面
    包名小写
    包名：公司名反着写：com.rupeng.crm.usr
    类之间互相引用：import com.rupeng.com.*(不推荐)
    import com.rupeng.com.Person（推荐）
    import static 方法，直接调用：
import static java.lang.Math.abs;
public class Main {

	public static void main(String[] args) {

		//abs 直接调用，不用写Math
		int i=abs(-3);
		System.out.println(i);	
	}
}
滑落的尖刀
关注
专栏目录
Java面试基础篇
m0_67392010的博客
07-29 3745
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。Java的强引用、弱引用、软引用、虚引用。Java语言基础常识。Java12新特性。JavaIO详解。...
封装，继承和多态（1）
t1z23456的博客
11-07 247
private defult 权限 extend关键字 继承中父类和子类成员/静态方法属性之间的关系 super 关键字
Educoder —Java面向对象 - 封装、继承和多态的综合练习（1）
陈陈不like的博客
11-01 1万+
通关任务1： 任务描述 本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。 相关知识 为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。 面向对象思想 构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）； new Object(Parameters)构造器调用构造函数，传参为了赋初始值； 对象的基本元素是：属性和方法 类成员（属性和方法）。属
Educoder -Java面向对象 - 封装、继承和多态的综合练习（ 第1关：通关任务一）
weixin_51160138的博客
02-28 3262
package case1; import java.util.Scanner; public class Task1 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String dogName = sc.next(); String dogSex = sc.next(); String dogColor = sc.next(); String catName = sc
Java进阶01-封装、继承与多态
K.SHI的博客
02-20 1372
面向对象编程的优势: 模块化编程，使维护和修改更加容易 代码重用 提高代码的可靠性以及灵活性 提高代码可读性 面向对象的程序设计有三大特征：封装、继承、多态。 1、封装性 封装性有两重含义，一是指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”到一个不可分割的对象中；二是指对信息的隐蔽，尽可能隐蔽对象的功能实现细节。 封装机制的另一个特点就是为封装在一个整体内的变量及方法规
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
JAVA面向对象基础测试题-继承-封装-多态等测试题.docx
09-30
根据给定文件的信息，我们可以总结出以下几个面向对象的基础知识点，并结合具体的题目来进行解析： ### 面向对象基础知识概述 面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它将数据和处理...
Java基础---面向对象---封装继承多态
MUYUFANSHENXUE的博客
04-11 1709
1，封装 //1,良好的封装能够减少耦合 //2,类内部的结构可以自由修改 //3,可以队成员进行更精确的控制 //4,隐藏信息，实现细节 //先将属性选择性的隐藏，然后将需要给他人调用的内容，提供getter setter当作入口，可以在getter，setter进行设置操作，确保属性安全 public class Dog { String dogName = "无名氏";//狗名称 private int age = 0;//年龄（0-15） char sex = '女'
Java面向对象编程（封装/继承/多态）实例解析
08-29
Java 面向对象编程（封装/继承/多态）实例解析 Java 面向对象编程是一种编程范式，它强调对象之间的交互和继承关系。在 Java 中，面向对象编程主要体现在三大特征：封装、继承和多态。 封装是指隐藏对象的内部细节...
Java面向对象进阶-封装、继承、多态
AnswerCoder的博客
10-16 1206
Java面向对象进阶 1.static关键字 static表示“静态”的意思，可以用来修饰成员变量和成员方法。 static的主要作用在于创建独立于具体对象的域变量或者方法 简单理解： ​ 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。 并且不会因为对象的多次创建而在内存中建立多份数据 注意 静态成员在类加载时加载并初始化。 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份(可以理解为所有对象公用 ) 在访问时：静态不能访
Educoder/头歌JAVA——JAVA面向对象：封装、继承和多态的综合练习
热门推荐
舟舟的博客
12-14 1万+
面向对象的三个基本特征： 封装，就是把客观的事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的信息隐藏。隐藏实现细节，使得代码模块化。 继承，可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。可以扩展已存在的代码模块。 多态，是允许你将父对象设置成为和一个或更多的它的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。父类引用指向子类对象。
面向对象进阶——封装、继承、多态
Jakey_src的博客
02-16 843
文章目录封装继承什么是继承为什么要用继承如何使用继承单继承下的属性查找顺序多继承下的属性查找super和MRO列表super()MRO列表多态与多态性组合 面向对象编程有三大特性：封装、继承、多态。下面来进行详细的学习吧！ 封装 ​ 封装的意思就是指把数据与功能整合在一起，需要使用的时候，再去调用，简单来说，也就是类的功能，类就是存放数据和功能的容器。除此之外，针对于封装到对象或者类中的属性，我们还可以控制对它们的访问，也就是隐藏属性，如果要详细了解，可以查看之前的笔记：面向对象基础——绑定方法、非绑定方法
头歌—— 封装、继承和多态的综合练习
weixin_62440328的博客
11-11 3701
【代码】头歌—— 封装、继承和多态的综合练习。
Java面向对象 - 封装、继承和多态的综合练习
qq_64010161的博客
03-08 3448
1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。 1.重写和重载；2.abstract(抽象类)和interface(接口)；3.final关键字；4.static关键字；5.多态。 Java面向对象的知识。
Java头歌4.2 类的封装、继承、多态（含抽象类、接口知识）
weixin_74284876的博客
11-03 2566
本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。
java笔记第七章之封装，继承和多态
l892675183的专栏
09-24 376
第七章：封装，继承，多态 @封装 #：什么是封装：用private修饰成员变量就叫做封装，封装通过私有访问符private来实现 #：封装的好处：1.提高内部的安全性 2，可以向外部屏蔽内部组成部分  #为什么要封装（原来不封装直接访问类的属性，例如MyClass my=new MyClass my.Color这种方法访问，通过封装后要通过get/set间接的访问）  疑问：不封
【Python进阶】：面向对象编程的力量：解锁封装、继承与多态的秘密武器
guting18893110463的博客
03-27 726
在Python编程世界中，面向对象编程（Object-Oriented Programming, OOP）如同一把锋利的剑，它将现实世界的实体抽象为类，赋予程序更强的结构化、模块化特征，极大地提升了代码的可读性、可维护性和复用性。在Python中，静态方法（Static Method）和类方法（Class Method）都是类级别的方法，它们的不同之处在于接收的主体对象以及访问类或实例的方式。：通过OOP，我们可以构建复杂的软件系统，通过继承和多态实现代码的复用与扩展，提高开发效率和代码质量。
封装、继承和多态进阶（一）
m0_64562382的博客
01-05 751
封装、继承和多态进阶（一）
ava面向对象 - 封装、继承和多态
最新发布
06-28
在Java中，面向对象（Object-Oriented Programming, OOP）三大核心特性分别是封装、继承和多态。下面是它们的简介： 1. **封装**： 封装是将数据和操作数据的方法组合成一个单独的单元（类），隐藏内部实现细节，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值