目录
一、继承中访问构造方法的特点
二、继承中访问成员变量的特点
三、继承中的方法重写
四、继承的优缺点
五、final
六、包
七、访问修饰符的权限
八、多态
九、多态的向上转型
十、多态的向下转型
十一、案例 父类作为参数时
十二、 父类作为返回值时
一、继承中访问构造方法的特点
1.调用自身构造方法使用关键字this
2.调用父类构造方法使用关键字 super
3.说明：
子类在初始化完成前，必须先初始化完成父类(因为子类可以获取父类的资源)
如果子类没有调用父类任何构造方法 就会默认调用父类的无参构造方法
如果子类调用了父类的构造方法 就不会默认调用父类的无参构造方法
如果父类只有有参构造方法 那么子类就必须调用父类的有参构造方法
所以在定义类的时候一般创建两个构造方法 一个无参 一个有参
4.注意点：
this() 和super()只能写在构造方法的第一行 且this()和super()不能同时存在
构造方法不能出现互相调用或者递归调用
其他方法都不能调用构造方法
二、继承中访问成员变量的特点
优先访问子类的成员变量 如子类没有则查找父类的成员变量 一直查到Object类 没有就报错
三、继承中的方法重写
1.方法重写的规则：在同一个类中，方法名相同，参数相同，与访问修饰符和返回值有关
2.方法重写的注释：@Override 用于检查是否是重写的方法
3.使用场景：在继承中，将共性资源抽取到父类中，将共性方法抽取到父类中的时候，需要使用父类的资源，但还需要在父类的基础功能上进行扩展 这时就可以使用方法重写
4.注意点：
重写方法的返回值类型不能超过父类方法的返回值类型的范围
重写方法的访问修饰符的严性不能大于父类方法的访问修饰符的严性权限
四、继承的优缺点
优点：提高代码的可复用性以及可扩展性
缺点：代码与代码之间的耦合度较高(代码与代码之间的关系比较密切)
五、final
1.final 表示最后、最终
2.它可以修饰：
类 ：使用final修饰就不能被继承
方法：使用final修饰就不能被重写
变量：使用final修饰的变量一般是常量 只能被赋值一次
3.说明：
a.在实际开发中final一边与static搭配使用
因为final修饰的数据不会发生改变 使用static可以直接通过类名进行访问 操作方便
b.使用final修饰引用数据类型的对象 不能改变的是地址值，可以改变对象的属性值
六、包
1.包：用于管理源代码文件，类似于电脑文件夹
2.作用：
用于管理源代码文件
避免类名冲突 在不同包中 可以创建相同名的类
3.组成：
包名全是小写，不同单词用‘.’分隔
组成：域名+公司名+项目名+包的具体含义
例子：com.qf.oa.utils工具包 com.qf.oa.dao操作数据库包
4.声明包：package +完整包名【idea自动声明包】例如: package com.qf.test08;
5.导包：
A.在使用其它包下类的资源的时候 就需要进行导包 例如:Scanner Math....
语法: import + 完整的包名+类名 例如:import java.util.Scanner;
B.使用java.lang包 下的资源不需要进行导包
6.注意点：
A.如果使用其它包的下类的资源 不想进行导包 那么必须使用完整的包名+类名
例子: java.util.Scanner input = new java.util.Scanner(System.in);
B.如果自定义的类名与jdk的提供的类冲突之后 优先使用自定义类
七、访问修饰符的权限
1.范围从大到小 public ==>protected ==>default ==>private
2.在实际开发中 如果需要对外提供访问的时候使用public
3.如果不需要对外进行访问的时候 使用private
八、多态
概念：一个事物或者一个对象有多形态 就是多态
前提条件：必须是在继承或者实现接口的前提下
特点：父类的引用指向子类对象
语法：父类类名 对象名 = new 子类类名()
图形解释：
多态访问成员变量的特点：编译看左边，运行看左边
多态访问成员方法的特点：编译看左边 运行看右边
例子：
//父类
package com.qf.test03;
public class Fu {
int numFu =12;
int num =21;
public void showFu(){
System.out.println("我是父类的方法");
}
public void show(){
System.out.println("我是父类的show方法");
}
}
//子类
package com.qf.test03;
public class Zi extends Fu {
int numZi=14;
int num=41;
public void showZi(){
System.out.println("我是子类的方法");
}
public void show(){
System.out.println("我是子类的show方法");
}
}
//测试类
package com.qf.test03;
public class Test {
public static void main(String[] args) {
//实例化多态对象
Fu fu = new Zi();
//访问成员变量：编译看左边 运行看右边
System.out.println(fu.numFu);
System.out.println(fu.num);
//访问成员方法：编译看左边 运行看右边
fu.show();
fu.showFu();
}
}
九、多态的向上转型
语法： 父类类名 对象名 = new 子类类名; 例如：Fu fu = new Zi();
解释：
问题：向上转型的对象不能获取到子类的独有资源
十、多态的向下转型
语法：子类类名 对象名 = (需要转换的子类类名)父类对象的引用 例如：Zi z = (Zi) fu
解释：
问题：有可能出现强制类型转换错误 ClassCastException
解决：判断是否可以还原成本身子类对象 使用关键字 instanceof 例子 ：p instanceof Dog
十一、案例 父类作为参数时
需求：
代码：
//Pet类
package com.qf.test04;
public class Pet {
//定义私有属性
private String name;
private int age;
private int health;
private int love;
//定义构造方法
public Pet() {
}
public Pet(String name, int age, int health, int love) {
this.name = name;
this.age = age;
this.health = health;
this.love = love;
}
//定义set和get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
//定义一个eat方法
public void eat(){
}
}
//Cat类
package com.qf.test04;
public class Cat extends Pet {
//定义构造方法
public Cat() {
}
public Cat(String name, int age, int health, int love) {
super(name, age, health, love);
}
//重写eat方法
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//Dog类
package com.qf.test04;
public class Dog extends Pet {
//定义构造方法
public Dog() {
}
public Dog(String name, int age, int health, int love) {
super(name, age, health, love);
}
//重写eat方法
@Override
public void eat() {
System.out.println("狗吃狗粮");
}
}
//Master类
package com.qf.test04;
public class Master {
public void feed(Pet p){
p.eat();
}
}
//Test类
package com.qf.test04;
public class Test {
public static void main(String[] args) {
//实例化主人类
Master m = new Master();
//使用多态实例化对象
Pet p = new Dog();
//m对象调用feed方法
//多态对象访问成员方法：编译看左边 运行看右边 父类中有eat方法就编译通过 然后子类中有eat方法就优先执行子类的方法
m.feed(p);
}
}
十二、 父类作为返回值时
package com.qf.test04;
public class Master01 {
public static Pet feed(String type){
Pet p =null;
if ("dog".equals(type)){
p = new Dog();
}else if ("cat".equals(type)){
p = new Cat();
}
//返回p对象
return p;
}
}
package com.qf.test04;
public class Test02 {
public static void main(String[] args) {
//通过类名访问静态方法
Pet p = Master01.feed("dog");
p.eat();
Pet p1 = Master01.feed("cat");
p1.eat();
}
}
