27访问修饰符以及面向对象的三大特征

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量91 收藏
点赞数
分类专栏： JAVA SE 文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanguato/article/details/125032085
版权

目录

访问修饰符

就是确定类、变量、方法等能不能够被正常访问的修饰符

Java本身提供了四个访问修饰符

  1. public 在任何地方都可以正常访问，权限最大
  2. protected 同包、子类、同类
  3. 默认（缺省） 不写 同包、同类
  4. private 同类
    注意：protected 、private 不能修饰类

举例

在这里插入图片描述在这里插入图片描述

面向对象的三大特征

封装

定义

从广义上来说，封装就是将物品保管起来封存起来
面向对象上说的封装，是一种特指：
将类的属性私有化（不在为外界提供直接访问属性的方式）
提供对应的getter 和 setter方法来访问和设置属性。

目的

封装的目的：数据的安全性和私密性

POJO（Plain Ordinary Java Object):经典的Java类

举例
package com.openlab.ke.code1;

//标准的Java bean
//JOPO

public class Admin {
	private String username;
	private String password;
	private int age;
	private String nickname;
	private String email;
	private String avatar;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public int getAge() {
		return age;
	}

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

	public String getNickname() {
		return nickname;
	}

	public void setNickname(String nickname) {
		this.nickname = nickname;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getAvatar() {
		return avatar;
	}

	public void setAvatar(String avatar) {
		this.avatar = avatar;
	}

	public Admin() {

	}

	public Admin(String username, String password, int age, String nickname, String email, String avatar) {
		this.username = username;
		this.password = password;
		this.age = age;
		this.nickname = nickname;
		this.email = email;
		this.avatar = avatar;
	}
	
	//tostring 就是用来test
	@Override
	public String toString() {
		return "Admin [username=" + username + ", password=" + password + ", age=" + age + ", nickname=" + nickname
				+ ", email=" + email + ", avatar=" + avatar + "]";
	}
	
	public static void main(String[] args) {
		Admin admin = new Admin();
		admin.setUsername("张三");
		admin.setAge(19);
		
		//java中，如果你在控制台上打印对象，默认toString
		System.out.print(admin);
	}

}


Admin [username=张三, password=null, age=19, nickname=null, email=null, avatar=null]

举例

在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

继承

在Java中，如果要有继承存在，被继承的类叫做父类（超类、基类），继承的类叫做子类（派生类），Java使用extends 关键字实现继承

定义

Java中，如果一个类，继承了另外一个类，则把这种现象叫做继承，此时这个类就会 继承父类（被继承的类）中的能够被继承的类成员（重点方法）

继承范围

子类会继承父类中的属性和方法

  • 如果父类和子类在同包中，只要不是private修饰的都能继承
  • 如果父类和子类在不同的包中，只能继承public、protected修饰的

举例

package com.openlab.ke.extend;

public class RichMan {
	public double money =1000000;
	protected String hourse = "白龙马";
	String car = "奔驰";
	private String ship = "神舟九号";
	
	public void say() {
		System.out.println("我对钱不感兴趣");
	}
	
	protected void say2() {
		System.out.println("我真是太傻了，竟然对钱没兴趣");
	}
	
	private void say3() {
		System.out.println("所以我到底对什么感兴趣");
	}

}


package com.openlab.ke.extend;

public class Son extends RichMan {
	public static void main(String[] args) {
		Son s = new Son();
		s.say();
		s.say2();
		
	}

}

继承的目的

面向对象的继承，就是为了提高代码的复用性。

覆盖（override) | 重写（overwrite）

当一个子类继承父类后，发现某个方法不满足自己使用的时候，重写（覆盖）该方法，实现能够满足自己使用的方法

方法

在Java中，重写父类方法，直接在子类中定义相同名称的方法即可
从jdk1.5开始，引入@Override这个注解
super关键字

package com.openlab.ke.extend;

public class Animal {
	
	public void say() {
		System.out.println("我是个小动物，但是我不知道怎么叫~~~~");
	}

}


package com.openlab.ke.extend;

public class Dog extends Animal {
	
	//重写父类方法，该方法名称必须和父类一样
	//访问修饰符，允许放大，不能缩小，建议保持一致
	//注解，标明是重写的方法
	@Override
	public void say() {
		System.out.println("汪汪汪");
	}
	
	public void say1() {
		System.out.println("wuwuwuw");
		//super关键字,调用父类的方法
		super.say();
	}
	
	public static void main(String[] args) {
		Dog d = new Dog();
		d.say1();
		//instanceof 关键字，用来判断对象是否是某个类的实例
		System.out.println(d instanceof Dog);
		
		
	}

}


wuwuwuw
我是个小动物，但是我不知道怎么叫~~~~
true

继承链

Java是典型的单继承机制，一个类只能有一个父类！！！
Java类存在一个根类（root class），object类！

instanceof关键字

用来判断对象是否是某个类的实例

final关键字

  • final修饰变量，该变量就会称为常量，不能够在被修改（runtime）
  • final可以修饰类，一旦final修饰类，该类就是最终类，不允许被继承
  • final还可以修饰方法，该方法为最终方法，该方法不允许重写（Override)
举例
package com.openlab.ke.extend;

public class TestFinal {
	//使用final定义常量
	public static final double PI =3.1415926;
	
	public static void main(String[] args) {
		System.out.println(PI);
	}

}

在这里插入图片描述

面试题

为什么String类会设计为final修饰

首先，被final修饰的变量，无论是类属性、对象属性、形参还是局部变量，都需要进行初始化操作。而String被final修饰主要由于两个方面：安全性和效率

一）效率：使用字符串池

final修饰的String，代表这个类不能被继承，而String是一个char类型的数组，证明它是不可更改的，但这也仅仅是引用地址不可改，再加上被private修饰，证明数组本身也不会改变。只有当字符串本身也不会变的时候才可以使用字符串池，这样节省空间

二）安全性：String类被final修饰不能被继承，无法修改，在多线程情况下也是安全的。

内部类

内部类可以直接访问包裹着它的外部类任何属性和方法（包括私有的）
一般而言，定义内部类，主要的目的肯定是在包裹着它的外部类中使用它

package com.openlab.code10.innerclass;

import com.openlab.code10.innerclass.TestInnerClass.Inner01;
import com.openlab.code10.innerclass.TestInnerClass.Inner02;


public class TestInnerClass {
	private int id = 10;
	private static String name;
	
	public void say() {
		Inner01 t = new Inner01();
		t.say();
	}
	
	//此时Inner01就是TestInnerClass的内部类
	class Inner01{
		public void say() {
			System.out.println(id);
			
		}
	}
	
	//static 可以修饰内部类
	//静态类（静态内部类），能直接访问外部类的静态属性
	public static class Inner02{
		public void say() {
			TestInnerClass tic = new TestInnerClass();
			System.out.println(tic.id);
			System.out.println(name);
			
		}
		
	}

}

class outer{
	public void say() {
		//如果在外界初始化内部类对象
		//TestInnerClass tic = new TestInnerClass();
		//Inner01 t1 = tic.new Inner01();
		
		Inner01 t1 = new TestInnerClass().new Inner01();
		t1.say();
		
		//如果是静态内部类，可以使用下面方式创建
		Inner02 t2 = new TestInnerClass.Inner02();
		
	}
}

import static

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

多态

一个事务的多种状态
多态是在继承的基础上存在的，父类引用指向子类实例

举例

package com.openlab.ke.polymorphic;

public class Pet {
	
	public String name;
	public int age;
	public int health;
	
	//宠物的治疗方案
	public void cure() {
		
	}
}


package com.openlab.ke.polymorphic;

public class QQ extends Pet {

	@Override
	public void cure() {
		System.out.println("充值");
		System.out.println("会员");
		System.out.println("开黑");
		System.out.println("然后就好了");
		this.health = 100;
	}
	
	

}


package com.openlab.ke.polymorphic;

public class Pig extends Pet {

	@Override
	public void cure() {
		System.out.println("大师兄说要给力");
		System.out.println("三师弟说要回家");
		System.out.println("我说要回高老庄");
		System.out.println("散伙了，我的病也好了");
		this.health = 100;
	}
	
	

}


package com.openlab.ke.polymorphic;

public class Master {

	private String name;
	private QQ qq;
	private Pig pig;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public QQ getQq() {
		return qq;
	}

	public void setQq(QQ qq) {
		this.qq = qq;
	}

	public Pig getPig() {
		return pig;
	}

	public void setPig(Pig pig) {
		this.pig = pig;
	}
	
	//治疗企鹅的方法
//	public void cure(QQ qq) {
//		if(qq.health <60) {
//			System.out.println("充值");
//			System.out.println("开黑");
//			System.out.println("会员");
//			System.out.println("封号");
//			qq.health = 100;
//			
//		}
//	}
//	
//	public void cure(Pig pig) {
//		if(qq.health <60) {
//			System.out.println("喊大师兄");
//			System.out.println("女菩萨真好看");
//			System.out.println("嫦娥妹妹真好看");
//			System.out.println("放开师傅冲我来");
//			qq.health = 100;
//			
//		}
//	}
	//多态，使用父类引用，来替代子类对象，此时父类引用代指的是所有子类对象
	public void cure(Pet pet) {
		if(pet.health < 60) {
			pet.cure();
		}
	}


}


package com.openlab.ke.polymorphic;

public class Test02 {
	public static void main(String[] args) {
		Master master = new Master();
		master.setName("张三");
		
		QQ qq = new QQ();
		qq.name = "帝王🐧";
		qq.age = 12;
		qq.health = 50;
		
		Pig pig = new Pig();
		pig.name = "八戒";
		pig.age = 420;
		pig.health = 30;
		
		master.setPig(pig);
		master.setQq(qq);
		
		master.cure(pig);
		master.cure(qq);
		
		
		
	}

}


大师兄说要给力
三师弟说要回家
我说要回高老庄
散伙了，我的病也好了
充值
会员
开黑
然后就好了
nanguato
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6.面向对象，类，访问修饰符
ColdArriveWu的博客
08-01 803
6.面向对象，类，访问修饰符 面向对象思想 概述 面向对象是基于面向过程的编程思想 面向对象的三大特征 封装 继承 多态 特点 是一种更符合我们思想习惯的思想 可以将复杂的事情简单化 将我们从执行者变成了指挥者 “万事万物皆对象” 只要是对象，就具备特征（属性）和行为（方法） 面向对象(OOP)与面向过程 ...
PHP面向对象——访问修饰符介绍
01-20
PHP中有三种访问修饰符，分别是： public（公共的、默认） protected（受保护的） private（私有的） 它们可以分别用在类的属性和方法上(类的属性和方法统称为类的成员)，用来修饰类成员的访问权限。 public（公共的...
2021.03.31面向对象之三大特征及访问修饰符
Amory的博客
04-01 89
面向对象的三大特征 继承、封装、多态。 继承 1.父类也称作超类、基类；子类：派生类。 2.JAVA中只有单继承，没有像C++那样的多继承，多继承会引起混乱，使得继承链过于复杂，系统难以维护。 3.子类继承父类，可以得到父类的全部属性和方法(除了父类的构造方法)，但不见得可以直接访问（比如父类私有的属性和方法）。 4.如果定义一个类时，没有使用extends，则他的父类是：java.lang.Object。 方法的重写 重写 父类中的方法没有办法满足子类的要求，这个时候我们就需要进行方法的重写。 # 重.
C#面向对象的三大特征
qq_43551373的博客
01-28 1122
面向对象三大特征 封装 1.面向对象编程的核心思想 2.对象：属性，方法，事件封装得到类 3.保证类的内容的数据结构的完整 4.属性封装，行为封装，对象封装，命名空间封装，解决方案封装 5.访问修饰符：设置类的成员访问权限 访问修饰符 public（公开） 所有类的类成员 访问范围：任何代码都可以访问 private（私有） 给所有类或者成员使用 访问范围：只能在本类中访问 pr...
Java面向对象编程三大特征 - 封装
热门推荐
微光点亮星辰
03-25 1万+
本文关键字：Java、面向对象、三大特征、封装。封装是面向对象编程中的三大特征之一，在对封装性进行解释时我们有必要先了解一些面向对象的思想，以及相关的概念。
面向对象编程的三大特征
weixin_39940206的博客
04-10 7024
面向对象编程的三大特征：封装、继承、多态 一：封装 对于封装而言，一个对象它所封装的是自己的属性和方法，所以他是不需要依赖其他对象就可以完成自己的操作。 封装的三大好处： 1、良好的封装能够减少耦合。 2、类内部的结构可以自由修改。 3、可以对成员进行更精确的控制。 4、隐藏信息，实心细节。 封装可以使我们容易的修改类的内部实现，二无需修改使用了该类的客户代码。 二：继承 继承是使用已存在的类定义...
浅析php面向对象public private protected 访问修饰符
10-27
本篇文章是对php面向对象public private protected 访问修饰符进行了详细的分析介绍，需要的朋友参考下
Java面向对象编程三大特征 – 封装
12-21
Java面向对象编程的核心特征之一是封装，它是将数据和操作数据的方法绑定在一起，形成一个独立的单元，对外界隐藏内部实现细节的过程。封装是面向对象设计的重要原则，它有助于提高软件的可维护性、安全性和复用性。...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 247
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 322
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 158
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 598
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 218
集合之Map
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 724
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 412
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 463
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java8新特性之FlatMap&Reduce
startqbb的博客
07-26 194
【代码】Java8新特性之FlatMap&Reduce。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 156
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 216
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值