三大特性

最新推荐文章于 2021-04-05 15:26:47 发布

编程小白(=_=)

最新推荐文章于 2021-04-05 15:26:47 发布

阅读量103

点赞数

分类专栏：笔记文章标签：多态封装继承

本文链接：https://blog.csdn.net/qq_51626328/article/details/115321392

版权

笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文介绍了Java的三大特性：封装中属性的private与public区别，通过set/get方法保护数据安全；继承实现代码复用，包括访问权限控制和方法覆盖；多态展示父类引用指向子类的灵活性，涉及类型转换和多态应用。

摘要由CSDN通过智能技术生成

Java的三大特性

一、封装

修饰符public和private

public代表公开的，在任何位置都可以访问被public修饰的成员

public class Student {
	public String name = "zhangs";
}
class Test{
	public static void main(String[] args) {
		Student s = new Student();
		String name = s.name;
	}
}

private代表私有的，被private修饰的成员仅在本类中可以被访问

public class Student {
	private String name = "zhangs";
}
class Test{
	public static void main(String[] args) {
		Student s = new Student();
		String name = s.name;//编译报错，无法访问被private修饰的属性
	}
}

封装的方式：

将属性使用private修饰

为属性提供相应的公开的通道方法，即set/get方法

public class Student {
	private String name;

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

set方法：用于对属性的值进行设置

public void set属性名(属性声明){
    this.属性名 = 形参名；
}

get方法：用于获取属性中存储的值

public 数据类型 get属性名(){
    return this.属性；
}

封装如何保护数据安全的：可以在方法中写入数据安全相关的代码，用来对数据的安全进行保护

通道方法的使用：

public class Student {
	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
class Test{
	public static void main(String[] args) {
		Student s = new Student();
		s.setName("zhangs");//通过set方法为属性赋值
		//省略业务代码
		String name = s.getName();//通过get方法获取属性的值
	}
}

二、继承

概念：继承是体现两个类之间具有 A类是一个 B类中的一种的表现

语法：在类声明的时候使用extends关键字

class SuperClass{//父类
}
class SubClass extends SuperClass{//子类的继承语法
}

优点：
1. 子类通过继承访问父类的成员，提高了代码的可复用性和可拓展性
2. 开发的时候不能强行使用继承关系，应该符合客观
访问修饰符：子类对父类成员访问权限的限制条件

本类同包子类任何
private √ × × ×
(default) √ √ × ×
protected √ √ √ ×
public √ √ √ √
1. 构造方法无法被继承
2. 四个修饰符都可以用来修饰成员变量，成员方法，构造方法
3. public和default可以修饰类
方法的覆盖(override)
1. 概念：在子类中使用独特的实现
2. 语法：方法名相同，返回值类型相同，参数列表相同，访问修饰符较父类相同或者更宽
3. 覆盖的检查：使用@Override注解进行语法的检查
```
class SuperClass {
	protected void menthod(int a) {

	}
}

class SubClass extends SuperClass {
	@Override
	public void menthod(int a) {

	}
}
```
继承关系中，对象的创建过程
1. 分配空间：对父类和子类所有属性赋予默认值
2. 虚拟机调用构造方法：
  1. 构建父类对象
    1. 构建父类对象
    2. 初始化属性：对所有属性赋予初始值
    3. 执行构造法中的代码：通过构造参数的传递进行属性的赋值
  2. 初始化属性：对所有属性赋予初始值
  3. 执行构造法中的代码：通过构造参数的传递进行属性的赋值
Java中的继承关系：Java是单继承，即一个类，只能有一个直接的父类，但可以有多个间接父类
构造方法无法被继承：

构造方法的语法中明确说明了，构造方法的方法名必须和类名保持一致

	本类	同包	子类	任何
private	√	×	×	×
(default)	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

super关键字的使用：

super. 的使用方式

super.属性名：访问父类的成员变量
**注意：**父类中必须具有该属性，否则编译报错

class SuperClass {
	public String name;
}

class SubClass extends SuperClass {
	public String name;
	public void method() {
		System.out.println(name);//访问本类的成员变量
		System.out.println(super.name);//访问父类的成员变量
	}
}

super.方法名(实参列表):访问父类的成员方法
**注意：**父类中必须具有该方法，并且参数列表能够匹配，否则编译报错

class SuperClass {
	public void superMethod(int a) {
		
	}
}

class SubClass extends SuperClass {
	public void subMethod(){
		super.superMethod(3);//调用父类中的成员方法
	}
}

super() 的使用方式：

super()或者super(实参)，代表调用父类的构造方法

class SuperClass {
	public String name;

	public SuperClass(String name) {
		this.name = name;
	}

	public SuperClass() {
	}
	
}

class SubClass extends SuperClass {

	public SubClass() {
		super();//指引虚拟机创建对象的时候，使用无参数构造方法
	}

	public SubClass(String name) {//可以通过构造方法给父类属性赋值
		super(name);//指引虚拟机创建对象的时候，使用有参数构造方法
	}
	
}

super()或者super(实参)必须声明在构造方法的第一行有效语句
如果在一个构造方法中没有显示声明super()或者super(实参)，则默认为super()。
当第一行有效语句为this()时，不能声明super()，虚拟机会根据this()的指引寻找对应的构造方法

三、多态

基本语法：

在继承关系中
父类引用指向子类对象

子类覆盖父类的方法

public class Test {
	public static void main(String[] args) {
		//父类引用指向子类对象
		Animal a = new Dog();
	}
}
class Animal{
	public void eat(){
		System.out.println("Animal eating");
	}
}
class Dog extends Animal{//继承关系
	@Override//覆盖父类的方法
	public void eat(){
		System.out.println("Dog eating");
	}
}

只能调用引用类型中所声明的成员方法(编译期进行检查)
运行时，如果子类覆盖了父类的方法，那么使用子类的实现
对象的实际类型不会因为其引用类型的改变而改变，当对象创建之后，其类型就不能被改变了

引用之间的转换

在多态中，如果需要调用子类独特的方法，需要将引用类型转换为子类类型

转换需要使用强制类型转换：

语法：子类数据类型变量名 = (子类数据类型)变量名;

public class Test {
	public static void main(String[] args) {
		Animal a = new Dog();
		Dog d = (Dog)a;//强制类型转换
	}
}
class Animal{
}
class Dog extends Animal{
}

只要引用类型间存在继承关系，那么编译一定通过，但是运行时可能出现异常(ClassCastException,类型转换异常)

public class Test {
	public static void main(String[] args) {
		Animal a = new Dog();
		Dog d1 = (Dog)a;//运行时正常
		
		Animal b = new Cat();
		Dog d2 = (Dog)b;//运行时异常
	}
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}

instanceof关键字：为了避免类型转换异常

语法：对象 instanceof 类，结果为boolean类型，判断对象的实际类型是否属于该类
代码

public class Test {
	public static void main(String[] args) {
		Animal a = new Dog();
		if(a instanceof Dog){//true
			Dog d1 = (Dog)a;
		}
		Animal b = new Cat();
		if(b instanceof Dog){//false
			Dog d2 = (Dog)b;
		}
	}
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}