Java学习_Day09

Java第九天学习内容：
1.继承
2.this和super的用法总结
3.抽象
4.综合案例练习

一、继承

关键词：extends
implements 是实现接口的关键词
理解：解决多子类中【共性抽取】的问题，提高了代码的复用性。

1.继承的格式

public class Father{
	//成员变量；
	//构造方法
	//成员方法
}
public class Son extends Father{
	//成员变量
	//构造方法
	//成员方法
}

2.继承中成员的访问特点
1)成员变量的访问特点
如果欲访问的变量，子类中存在就先访问子类中的这个变量，如果没有就访问父类，如果父类也没有，就报错。
this.成员变量—>指明访问本类的成员变量
super.成员变量—>指明访问父类的成员变量
2).成员方法的访问特点
子类有就先用子类的，子类没有就用父类的，如果父类也没有就报错。
方法重写（复写/覆盖）：在子类父类关系中有一模一样的方法。
方法重写的注意事项：
1).@Override:注解，起到标记提示的作用
写在方法上面，起到检测方法是否正确覆盖如果没有就报红提示，其实就算不写，如果方法没问题也能完成对父类相同方法的覆盖
2).重写方法的返回值类型的范围，必须【小于等于】父类返回值类型的范围
3).重写方法的权限修饰符的范围，必须【大于等于】父类返回值类型的范围

public > protected > 默认的(default不用写出来) > private

【小结：实际运用方法重写，只需要和父类写得一模一样就可以了】

方法重写的好处：既能保证父类的方法不变，子类也可以根据自己的需求做不同的实现。

代码案例：

public class Phone{
					public void show(){
						System.out.println("来电显示");
					}
				}
				
				public class NewPhone extends Phone{
					@Override//提示该方法是重写父类的show方法
					public void show(){
						super.show(); //调用父类方法
						System.out.println("显示头像");
						System.out.println("显示姓名");
					}
				}

3)构造方法的访问特点
a:子类所有的构造器(构造方法)都会默认去访问父类的空参构造器
在构造方法的第一行隐含的一句super()；访问父类的空参构造方法

b:如果父类没有空参构造器，子类可以通过super(参数)；去调用父类的有参构造器

3.this和super的用法总结

super：引用父类对象
super.成员变量 调用父类的成员变量(用来访问父类被隐藏的成员变量即就是private关键字修饰的成员变量只能被间接访问)
super.成员方法 调用父类的成员方法(调用父类中被重载的方法)
super() 调用父类的空参构造器
super(参数) 调用父类的有参构造器

this：访问(调用)当前类的对象
this.成员变量 访问当前类的成员变量
this.成员方法 调用当前类的成员方法
this() 访问当前类的空参构造器
this(参数) 访问当前类的有参构造器

注意：
不管是 this()、 super() 还是 this(参数)、 super(参数) 只能写在构造方法的第一语句
即super()和this的用法一样的
在构造方法中：
都必须得是第一行，所以二者不可共存
super用法注意：
在子类的构造方法中调用父类构造方法只能访问一次
即子类中：不能同时存在super()，和super(参数)两条语句

4.继承的特点
1)Java只能单一继承
一个儿子只能有一个爸爸
2)Java支持多层继承
爸爸也可以有爸爸
3)一个类可以有多个子类
爸爸可以有多个儿子

二、抽象

关键字：abstract

抽象类和抽象方法

//抽象类(有抽象方法的类，必须是抽象类)
	public abstract class 类名{
		//抽象方法
		public abstract void 方法名(); //没有方法体
		//具体方法
		public void 方法名(){
			
		}
	}

抽象类是干什么用的？
答：抽象类就是用来给子类继承的，限定和约束子类，一个子类继承抽象类必须重写所有的抽象方法。
抽象的注意事项：
1)抽象类不能创建对象即不能直接new对象
2)抽象类中可以有抽象方法，也可以有普通方法(非抽象方法)（含有抽象方法的类一定是抽象类，但抽象类不一定有抽象方法也不只有抽象方法，抽象方法只能存在于抽象类中）
3)子类继承(extends)抽象类，必须重写父类所有的抽象方法
4)如果子类也是抽象类，可以不用重写其父类的抽象方法
类的成员：成员变量+常用方法+构造方法

三、综合案例练习

有乒乓球运动和篮球运动员，还有乒乓球教练和篮球教练
乒乓球运动打乒乓球、篮球运动员打篮球
乒乓球教练教乒乓球，篮球教练教打篮球
使用类和抽象把乒乓球运动、乒乓球教练、篮球运动员、篮球教练

人类
	--教练类
		--乒乓球教练
		--篮球教练
		
	--运动员类
		--品牌球运动员
		--篮球运动员

结构图：

根类：Person

package com.itheima.Test;

public abstract class Person {
    public String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //抽象方法
    public abstract void eat();
    public abstract void sleep();
}

父类：Coach类

package com.itheima.Test;

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name) {
        super(name);
    }

    //教学方法
    public abstract void teach();
}

父类：Player类

package com.itheima.Test;

public abstract class Player extends Person {
    public Player() {
    }

    public Player(String name) {
        super(name);
    }

    public abstract void play();
}

实现类1：PingPongCoach

package com.itheima.Test;

public class PingPongCoach extends Coach{
    public PingPongCoach() {
    }

    public PingPongCoach(String name) {
        super(name);
    }

    //重写直接父类的抽象方法
    @Override
    public void teach() {
        System.out.println("教练教的很专业！棒棒哒");

    }
    //重写父类类的抽象方法
    @Override
    public void eat() {
        System.out.println("教练的餐配-->三菜一汤");
    }

    @Override
    public void sleep() {
        System.out.println("教练的每天睡八个小时~");
    }
}

实现类2：PingPongPlay类

package com.itheima.Test;

public class PingPongPlay extends Player {
    @Override
    public void play() {
        System.out.println("乒乓球运动员，爱打乒乓球~~~");
    }

    @Override
    public void eat() {
        System.out.println("我每天吃得很营养！！！");

    }

    @Override
    public void sleep() {
        System.out.println("我每天睡7个小时........");
    }
}

实现类3：BasketBallCoach

package com.itheima.Test;

public class BasketBallCoach extends Coach {
    public BasketBallCoach() {
    }

    public BasketBallCoach(String name) {
        super(name);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教篮球运动员打篮球");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练的餐配-->四菜一汤");

    }

    @Override
    public void sleep() {
        System.out.println("篮球教练每天睡7个小时.....");

    }
}

实现类4：BasketBallPlay 类

package com.itheima.Test;

public class BasketBallPlay extends Player {
    public BasketBallPlay() {
    }

    public BasketBallPlay(String name) {
        super(name);
    }

    @Override
    public void play() {
        System.out.println("我爱打篮球");
    }

    @Override
    public void eat() {
        System.out.println("我吃肯德基喝牛奶");
    }

    @Override
    public void sleep() {
        System.out.println("每天睡八个小时，中午午休！");
    }
}

测试类：Demo04

package com.itheima.Test;

public class Demo04 {
    public static void main(String[] args) {
        //篮球教练
        BasketBallCoach basketBallCoach = new BasketBallCoach("乔丹");
        System.out.println(basketBallCoach.getName());

        basketBallCoach.eat();
        basketBallCoach.sleep();
        basketBallCoach.teach();
        System.out.println("*****************");
        //篮球运动员
        BasketBallPlay basketBallPlay = new BasketBallPlay("库里");//每个类都有一个空参构造器

        System.out.println(basketBallPlay.getName());
        basketBallPlay.eat();
        basketBallPlay.play();
        basketBallPlay.sleep();

        System.out.println("-------------------------");

        //乒乓球教练
        PingPongCoach pingPongCoach = new PingPongCoach();
        pingPongCoach.setName("刘国梁：");
        System.out.println(pingPongCoach.getName());
        pingPongCoach.eat();
        pingPongCoach.sleep();
        pingPongCoach.teach();
        System.out.println("************************");
        //乒乓球运动员
        PingPongPlay pingPongPlay = new PingPongPlay();
        pingPongPlay.setName("马龙:");
        System.out.println(pingPongPlay.getName());
        pingPongPlay.eat();
        pingPongPlay.play();
        pingPongPlay.sleep();

    }
}

运行结果：

乔丹
篮球教练的餐配-->四菜一汤
篮球教练每天睡7个小时.....
篮球教练教篮球运动员打篮球
*****************
库里
我吃肯德基喝牛奶
我爱打篮球
每天睡八个小时，中午午休！
-------------------------
刘国梁：
教练的餐配-->三菜一汤
教练的每天睡八个小时~
教练教的很专业！棒棒哒
************************
马龙:
我每天吃得很营养！！！
乒乓球运动员，爱打乒乓球~~~
我每天睡7个小时........

子类又叫派生类
父类又叫超类，基类

【构造方法的方法名和类名相同】

Java学习第十天内容链接：
https://blog.csdn.net/LJN951118/article/details/88960563