继承 访问权限修饰符 final 重写 super

为什么需要学习包?

1.方便管理Java文件
2.解决同包下类重名问题

包的本质 就是 文件夹

包的命名规范: 所有单词小写,每一个单词使用.隔开,公司域名反写

包声明格式: package 包名1.包名2.包名3…包名n;

包的导入格式: import 包名1.包名2.包名3…包名n.类名;

类名的全路径[类路径]: 包名1.包名2.包名3…包名n.类名 ClassNotFoundException

包的特点:

1.同包下的类不需要导包
2.java.lang包下的所有类都不需要导入,系统会帮我们导入
3.如果一个类没有声明包,那么意味着这个类将是孤立的类,其他包都无法访问默认包下的所有类,一般先建包再建类
4.如果在同一个类下使用两个不同包下的同名类的时候,需要使用类路径
5.包的声明必须出现在Java文件的第一句,仅且只有一句
6.在书写类名的时候不要和系统的类重名
7.如果需要导入一个包下所有的类,可以使用通配符 *
8.JDK常见一些包:
java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.awt
包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
java.net
包含执行与网络相关的操作的类。
java.io
包含能提供多种输入/输出功能的类。
java.util
包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。

Ctrl + Shift + O 一键导包
Ctrl + 1 单个导包

为什么需要学习继承?

1.简化了代码
2.提高了扩展性和可维护性

OOA : 分析一共涉及到多少个对象,多少个类
OOD : 类与类之间的关系

•  	a.继承  A is a B
  

•  	b.组合  A has a B
  

  OOP : 在主方法中,不断创建对象,使用对象,指挥对象做事情[调方法调属性]

继承的本质: 类是对一批对象的抽象,继承是对一批类的抽象,继承本质就是抽取多个类共性代码

继承的格式:

	class 子类 / 派生类  extends 父类/基类/超类 {
	}

继承的好处:
1.简化了代码
2.提高了扩展性和可维护性
3.继承是多态的必要条件 (后面讲解多态的时候详细讲解)

继承的缺点
1.违背高内聚,低耦合的设计原则,继承是一把双刃剑
继承慎用 【牵一发动全身】 继承的缺点是无法弥补的
以后尽量使用接口 【面向接口编程】

继承的注意事项:
1.继承不支持多继承,但是支持多层继承
2.如果一个父类的属性使用private修饰,那么该属性对子类不可见
3.如果子类集成了父类的属性和方法,那么子类还可以有自己的属性和方法
如果子类属性覆盖了父类属性,那么子类优先
4.子类不能够继承父类的构造方法

如何来使用继承?
1.先写子类
2.观察多个子类之间是否存在共性代码
3.定义父类保存多个子类的共性代码,将子类继承父类
4.将子类共性代码删除
5.验证 : 检查子类和父类之间是否满足 is a 的关系

什么时候继承?
1.抽取共性代码
2.当设计一个非常复杂的类的时候可以考虑使用继承
3.当使用多态的时候必不可少地需要用到继承

---

为什么需要学习final关键字

修饰变量成为自定义常量,可以提高程序的可读性,同时不能够被二次赋值

常量的分类:
字面值常量: 2 2.5 false null "abc"
自定义常量: public static final int NUM = 100;

final: 最终的, 最后的

final能够修饰变量 方法 类

final修饰变量 只能够赋值一次,表示常量, 可以提高程序的可读性
成员变量: 必须给出默认值,后期系统会赋值默认值
局部变量: 没有默认值,可以后面自己给默认值
final 修饰方法 不能够被子类重写
final 修饰类 不能够被继承

final class A {
	public final int NUM = 200;
	
	public void show() {
//		NUM = 200;//必须给出默认值,否则编译报错，因为后期系统会赋值默认值
		final int I;//没有默认值,可以后面自己给默认值
		I = 200;  
		// I = 300;
	}
	
	public final void test() {
		
	}
}

---

访问权限修饰符

用于提高数据的安全性,控制外界的访问级别,是封装的具体体现

访问权限修饰符分为:
public protected default[表示一种没有加以任何修饰的状态] private

访问权限修饰符的特点:
1.public 对所有类可见 (项目可见性)
2.protected 对同包下以及同包下的子类可见 (子类可见性)
3.default 对同包下可见 (包可见性)
4.private 仅对本类可见 (类可见性)
5.访问权限修饰符 可以修饰 成员变量 成员方法 构造方法, 也可以修饰类,只有 public default 可以
但是内部类可以使用 private protected 修饰
6.访问权限修饰符的 宽严 关系
public > protected > default > private
7.我们经常提到的封装就是通过 访问权限修饰符 实现

为什么需要学习方法重写? --> 父类的功能实现无法满足子类的需求,需要重写

重写的特点:
1.发生在具有子父类两个关系的类中
2.方法名称相同
3.参数的列表完全相同
4.返回值类型可以相同也可以是其子类
5.访问权限修饰符不能够严于父类
6.重写是多态的必要条件
7.抛出的异常不能比父类的异常更大 (后面讲解异常的时候详细讲解)
8.私有修饰的方法不能够被继承,就更不可能被重写

面试题: 重写和重载的区别

---

为什么需要学习super?

能够帮助子类 初始化 父类继承下来的成员,从而简化代码
super的定义:
          this代表当前对象,创建任何一个对象,都会创建一个this引用和该对象指向同一个堆区的空间,this就是一个地址
          super代表父类存储空间的标识,super可以通过这个标识访问父类的成员,super可以理解为父类对象,
          this可以作为参数传入到方法的形参中,super不可以

super和this访问成员的特点:

	成员变量
		this.成员变量
		super.成员变量
	成员方法
		this.成员方法
		super.成员方法
	构造方法
		this(参数列表)
		super(参数列表)

• 1.为什么访问子类构造方法之前会访问父类构造方法? – 访问父类无参构造方法导致所有的父类的静态成员和静态代码块被加载,最终根类Object类的注册方法也会被加载
• 2.访问子类构造方法会访问父类构造方法,那么会不会创建子类对象的同时创建父类对象? 不会 使用super/this方法构造方法就相当于调用普通方法,需要创建对象访问构造方法必须结合 new
• 3.任何一个构造方法第一句都会先访问父类无参构造方法
• 4.this super 访问构造方法必须出现第一句
• 5.this 和 super 访问构造方法不能够共存
• 6.super可以访问父类的成员
• 7.static上下文不能够出现this super

题目

public class SuperDemo02 {
	public static void main(String[] args) {
		Son son = new Son();
		son.show();
	}
}

class Father {
	int num = 30;
	
	public void show() {
		int num = 40;
		System.out.println(num);
	}
}

class Son extends Father {
	
	int num = 20;
	public void show() {
		int num = 10;
		// 希望打印结果是 10
		System.out.println(num);
		// 希望打印结果是 20
		System.out.println(this.num);
		// 希望打印结果是 30
		System.out.println(super.num);
		// 希望打印结果是 40
		super.show();
	}
	
}

public class SuperDemo03 {
	
	public static void main(String[] args) {
		Zi zi = new Zi();
		System.out.println(zi.num);
	}
}

class Fu {
	
	int num = 10;
	
	public Fu() {}//如果父类没有无参构造器，会编译报错
	
	public Fu(int num) {
		this.num = num;
	}
}

class Zi extends Fu {
	int num = 20;
}