10.9-10.11Java - 面向对象3要素

尚兴龙。

已于 2022-10-14 15:36:22 修改

阅读量80

点赞数

文章标签： java jvm spring

于 2022-10-12 10:46:44 首次发布

本文链接：https://blog.csdn.net/goodgods_/article/details/127278263

版权

面向对象三要素

封装
继承
多态

1.封装

定义：成员变量私有化，提供公共的set和get方法

public class Test2 {

	private String name;
	private int age;
	
	//给变量赋值set
	public void setName(String name) {
		//This关键字表示的是调用该方法的当前对象
		this.name = name;
	}
	//get获取变量的值
	public String getName() {
		return name;
	}
}
class T3{
	public static void main(String[] args) {
		test2 t = new test2();
		t.setName("小明");
		System.out.println(t.getName());
	}
}

同文档中只能有一个类是public的

快速生成set和get方法

类文件空白位置，点击鼠标右键——source——Generate Getters and Setters

2.继承

定义：子类可以不需要声明，直接调用父类的资源（成员变量与方法）

继承的特点：

所有类都有父类，即所有类都派生于Object类
只能单亲继承，即每一个子类只能有一个父类
子类只能继承父类的非私有方法和变量
- 子类不能继承父类的私有属性
- 如果子类中共有的方法影响到了父亲私有属性，那么私有属性是能够被子类使用的（即通过父类的公有方法访问到父类的私有变量）
子类可以直接使用继承的变量和方法，不需要再在子类中声明或写出

重写

重写发生在子父类中
重写的方法名相同，参数列表相同
重写的方法体不同
子类重写的方法，权限不能缩小

3.多态

没有继承就没有多态，生成的对象，在调用父类方法时，如果方法被子类重写，则调用的是子类重写的方法。

代码当中体现多态性，其实就是一句话：父类引用指向子类对象

格式：父类对象名 = new 子类();

再Java中，有两种形式可以实现多态：继承和接口

方法的重载实现的是编译时的多态性（也成为前绑定），而方法的重写实现的是运行时的多态性（也成为后绑定）。

super关键字

表示当前类的父类对象，可以使用super关键字对父类变量和方法的访问

子类方法中无论写不写super()，Java都默认使用super()调用父类的构造方法

特点：

用在子类构造方法中
无论写不写super()，Java都会默认使用super()调用父类的构造方法
只能通过super()调用父类的构造方法一次
通过super()调用父类的构造方法，必须放在子类构造方法的第一行

public class Father {
	protected String name;
	
	public void test() {
		System.out.println("父类方法");
	}
}

/*
 *面向对象 类为单位
 *面向过程 方法为单位
 * */
 




/*
 * 重写的特点
 * 重写发生在子父类中
 * 重写的方法名相同，参数列表相同
 * 重写的方法体不同
 * 子类重写的方法，权限不能缩小
 * */
public class Son extends Father{

	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("子类方法");
	}

	public static void main(String[] args) {
		Father son = new Son();
		son.test();
	}

	
}

JVM类加载的顺序（static）

静态代码块>new>代码块>构造方法

public class Son extends Father{
	static {
		System.out.println("静态代码块");
	}
	{
		System.out.println("代码块");
	}
	public Son() {
		System.out.println("构造方法");
	}
	public static void main(String[] args) {
		new Son();
	}
}

特点

static生命的资源只能被初始化一次
修饰变量称为静态变量，局部变量不能被static修饰，因为static有全局的意思
修饰方法，称为静态方法，静态方法只能调用其他静态资源，不能调用非静态变量，不能被this和super，因为静态资源的加载先于实例化
static修饰的变量或者方法独立于任何类，他不依赖类的特定对象，该类被所有对象共享
修饰内部类，外部类不需要实例化，可以直接通过外部类名直接调用

面向对象类为单位
面向过程方法为单位

final关键字

修饰类，类不能被继承
修饰方法，方法不能被重写
修饰变量，称为常量，常量的值不能被修改；常量名必须大写，且声明常量的时候就得给常量赋值
修饰基本数据类型，变量的值不能被改变
修饰引用类型（对象），该对象的引用（内存地址）不能被改变

final int NO = 12;
final String NAME = "abc";

抽象类

定义：抽象类不能实例化，它的作用是提供给其它类进行继承

抽象类特点：

修饰类，类为抽象类，不能被实例化
修饰对象，方法为抽象方法，只有方法的签名，没有方法体

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v7us7ZC7-1665732977596)(C:\Users\19912\AppData\Local\Temp\1665459012674.png)]

public class GrandFather {

	public GrandFather(String name) {
		
	}
}




/*抽象类
 * 定义：抽象类不能实例化，它的作用是提供给其它类进行继承
 * 
 * 抽象关键字abstract
 * 特点：
 * 1 修饰类，类为抽象类，不能被实例化
 * 2 修饰对象，方法为抽象方法，只有方法的签名，没有方法体
 * */
public abstract class Father extends GrandFather{
	public Father(String name) {
		super(name);
	}
	//方法的签名
	public abstract void run();
}



public class Son extends Father{

	public Son(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}

}

接口

Java遵循：

单继承多实现

先继承后实现

接口的特点：

接口只有方法的签名和静态常量
接口变量默认public final static修饰
接口的签名方法，会默认用public abstract修饰
接口不能自身实例化，接口的实现类可以实例化
子类实现接口，必须重写就扣的所有签名方法
接口可以实现多个，而父类只有一个
遵循 单继承多实现，先继承后实现

接口的优点：

解决Java开发的单继承问题
接口可以实现并行开发
便于重构


/*
 * implements实现接口关键字
 * 
 *继承与实现的规则
 * java中遵循
 * 单继承多实现
 * 先继承后实现
 * 
 * 接口的特点：
 * 
 * */

public class Tom implements IPerson,IPlayer{

	@Override
	public void speak() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public String fun1() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int fun2() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}

}