三大特性

面向对象的三大特性

封装

思想：该露的露，该藏的藏

封装（数据的隐藏）：通常，应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口在访问，这称为信息隐藏

程序设计追求“高内聚、低耦合”

高内聚：累的内部数据操作细节都是有自己完成，不允许外部干涉

低耦合：尽量暴露少量的方法给外部使用

属性私有getset

public class C {
	//私有：private
	private String name;
	private int id;
	private char sex;
	
	//提供可以操作这些属性的方法
	//public 的get和set方法
	public String getName() {
		return this.name;
	}	
	public void setName(String name) {
		 this.name=name;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getId() {
		return id;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public char getSex() {
		return sex;
	}

}

封装的意义：

提高代码的安全性，保护数据
隐藏代码的实现细节
统一接口
提高系统的可维护性

继承

继承的本质是对某一批类的抽象，从而实现对现实世界的更好建模

extends的意思是扩展，子类（派生类）是父类的扩展
java中只有单继承，没有多继承，一个人不会有两个爹

继承是类和类的一种关系。除此之外，类和类的关系还有依赖、组合、聚合等。继承关系的两个类一个为子类（派生类），一个为父类（基类）。子类继承父类。使用关键字 extends来表示。

子类和父类之间，从意义上来讲应该具有“is a”的关系。
父类私有的属性不可以被继承
在java中，所有的类都直接或者间接继承于object类

super

//测试类
public class D{

	public static void main(String[] args) {
		Student s=new Student();//调用了父类和子类的构造方法
		//s.test("呱呱");
		//s.test1();
	}
}

//父类
public class Person {

	protected String name="sw";
	
	public void print(){
		System.out.println("我是父类");
	}

	public Person() {
		System.out.println("父类的无参构造执行了");
	}
}
//子类
public class Student extends Person {
	private String name = "xioaming";

	
	public Student() {
	//	super();//默认调用了父类的构造器，必须在子类构造器的第一行，可以省略
		System.out.println("子类的无参构造执行了");
	}
	public void test(String name) {
		System.out.println(name);//传进参数：呱呱
		System.out.println(this.name);//子类：xioaming
		System.out.println(super.name);//父类：sw
	}
	
	public void print() {
		System.out.println("我是子类");
	}
	
	public void test1() {
		print();//子类的方法
		this.print();//子类的方法
		super.print();//父类的方法
	}
}

一个类中必须要有无参构造，尤其是加上有参构造之后

super注意点：

super调用父类的构造方法，必须在构造方法的第一行
super必须只能在子类的方法或者构造方法中
super和this不能同时调用构造方法

同时和this相比
- 代表的对象不同，this代表本身调用的这个对象，super代表父类对象的调用
- this没有继承也可以使用，super只能在继承条件下才能使用
- this();本类的构造 super();父类的构造

方法的重写

重写是方法的重写和属性无关

//测试类
public class D {

	public static void main(String[] args) {

		Student a = new Student();
		a.test();

		Person b = new Student();// 父类的引用指向了子类
		b.test();

	}
}
//父类
public class Person {

	public static void test() {
		System.out.println("父类");
	}
}
//子类
public class Student extends Person {
	
	public static void test() {
		System.out.println("子类");
	}
}

此时的输出结果为：父类子类

父类和子类中的静态方法不是对象的方法，而是加载了类之后就有的方法，也就是类的静态方法，此时无论创建的对象new给了谁，都只是调用了这个类的方法

//测试类
public class D {

	public static void main(String[] args) {

		Student a = new Student();
		a.test();

		Person b = new Student();//向上转型，详情见多态
		b.test();

	}
}

//父类
public class Person {

	public  void test() {
		System.out.println("父类");
	}
}

//子类
public class Student extends Person {

	@Override //注释，意思为重写
	public void test() {
		System.out.println("子类");
	}
}

输出结果为：子类子类

注意的点：

重写的方法的修饰词不能是private，不能写静态方法
需要有继承关系，子类重写父类的方法
方法名和参数列表必须相同，修饰符范围可以扩大不可以缩小
跑出的异常范围可以被缩小但是不能扩大

重写的意义：

子类可以剔除不满足的方法

多态！！

实现动态编译

一个对象的实际类型是确定的，但是引用的类型是不确定的

Person p=new Student();//向上转型

对象实例化之后引用子类，变成父类的类型之后向上转型，向上转型之后其中子类的独有方法就无法使用了，调用父类被子类重写的方法时，出现的是子类的结果。

对象能执行哪些方法主要看左边的类型，编译看左边，执行看右边
子类重写了父类的方法，就执行子类的方法
向上转型父类类型只能调用与子类重写的方法，子类独有的方法无法调用
多态是方法的多态，不是属性的多态
ClassCastException 类型转换异常
存在条件：继承关系、方法重写，父类引用指向子类对象
static 属于类，不属于实例 final 常量 private 私有，无法被重写

posted @ 2021-08-06 09:20 甲乙丙I 阅读(82) 评论(0) 收藏举报

刷新页面返回顶部

甲乙丙I

三大特性

面向对象的三大特性

封装

继承

super

方法的重写

多态！！

公告