day11

1.成员变量和局部变量的区别
	成员变量：
		定义在类体中，整个类可以使用
	局部变量:
		定义在方法中，只能在方法使用
2.继承的语法格式
	class B extends A {
	
	}
3.关于属性和方法子类继承父类一些要求
	不能使用父类的私有化的属性和方法
4.重写的目的
	父类的需求不能满足子类的需求
5.重写和重载的区别
	重写：
		1.必须继承关系
		2.在子类中去重写
		3.除了方法体不一样其他都一样的
		4.不能是私有化方法
	重载:
		1.必须再一类中，至少两个方法
		2.方法名字必须一样，参数类型 一定不一样
		3.返回值可以不一样
6.多类合作
	成年人类
		孩子类
			玩具类
	一个类中让另外一个类对象作为属性看待
7.一个类对象作为一个方法的参数的案例
	人喂狗  狗吃饭
	public void feed (Dog dog) {}

今天的内容

1.super关键字【鸡肋】

2.抽象类

3.final关键字

4.接口

1.super关键字

只能用于继承，并在子类中使用。代表的意思是父类对象

this:

​ 代表当前类对象。

​ 可以调用属性和方法

​ 可以调用构造方法

super:

​ 代表是父类的对象

​ 可以调用父类的成员变量和成员方法

​ 注意事项:当super调用属性的时候，就是内存里面那一个

​ 可以调用父类的构造方法

​ 真实开发的时候， super.父类的方法。证明在调用父类的方法

package com.qfedu.b_super;
class Father1 {
	String name;
	public Father1 () {
		System.out.println("Father1的无参构造");
	}
	public Father1 (String name) {
		System.out.println("Father1有参构造");
	}
}
class Son1 extends Father1 {
	//在子类中无论你写了有参构造和无参构造，都要去执行父类的无参构造
	//除非你自己调用父类有参构造方法
	public Son1(String name) {
		//在调用父类的无参构造方法
		//super();
		super("狗蛋");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		Son1 son1 = new Son1("狗蛋");
		
	}

}

2.抽象类【重要】

在面向对象中，所有的对象可以通过类来创建。反过来说，并不是所有的类都可以创建对象的。如果一个类中没有足够完整的信息来描述具体的对象的话，那么这个类叫抽象类。

在Java中使用关键字abstract修饰类，这个类叫抽象类。

2.1abstract关键字

abstract修饰的类叫抽象类

abstract修饰的方法叫抽象方法

总结：abstract 只能修饰类和方法

语法格式:

abstarct class 类名｛
	普通的方法;
	public void eat () {
	
	
	}
	抽象方法;
	public abstarct void sleep ();
｝

入门案例：

先学会说声明出来一个抽象类

package com.qfedu.c_abstract;

//声明一个抽象类
abstract class Person {
	
	//在抽象类中可以写普通成员方法
	public void eat () {
		System.out.println("今天中午吃外卖。。。。。。");
	}
	//定义一个抽象方法  是不完整的方法  没有方法体的
	abstract public  void work();
	
}
//定义了咋用啊？ 抽象类创建不了对象的 咋解决？
//解决方案: 再写一个普通类去继承抽象类即可
class Man extends Person {
	//the type Man must implement the inherited 
	//abstract method Person.work()
	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("劳动力");
	}
	
	
}
public class Demo1 {
	public static void main(String[] args) {
		Man man = new Man();
		man.eat();
		man.work();
	}

}

注意事项：

​ 1.如果一个类中用abstract修饰的话，那么这个类叫抽象类

​ 2.抽象类中可以有普通成员方法和抽象方法

​ 3.抽象方法没有方法体，是不完整的方法

​ 4.抽象类不能被实例化

​ 5.写一个普通的类去继承抽象类

​ 6.在子类中一定去实现（重写）抽象类中所有的抽象方法

​ 7.非抽象方法可以重写也可以不重写

​ 8.一个抽象类能不能去继承另外一个抽象类？ 可以的！！！

​ 9.抽象类可以继承非抽象类

package com.qfedu.c_abstract;

class Cell {
	public void add () {
		System.out.println("分裂");
	}
}
abstract class Animal extends Cell{
	public abstract void run();
}
abstract class Monkey extends Animal{//抽象类
	public void call () {//普通的成员方法
		System.out.println("咿咿呀呀.......");
	}
	public abstract void eat();
	public abstract void sleep();
}
class People extends Monkey {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃肉！！！");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("躺着睡。。。");
	}
	@Override
	public void call() {
		System.out.println("嘻嘻哈哈说话");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("人站立奔跑。。。");
	}
	
}
public class Demo2 {
	public static void main(String[] args) {
		People people = new People();
		people.add();
	}
}

练习：

​ 抽象类:

​ Animal:

​ play()方法 抽象方法

​ eat方法 抽象方法

​ sleep方法 普通方法

​ Panda类去继承ANimal

​ Cat类去继承ANimal

​ 实例化Panda Cat 调用 上面的几个方法。

上午讲的

1.super关键字
	1.可以调用父类的成员变量和成员方法
	2.可以父类的构造方法，在子类的构造方法中
	
2.抽象类语法格式
	

3.final关键字

final中文意思: 修饰符

​ 最终的，最后的

用法：

​ 1.final可以修饰成员变量

​ 使用final修饰的成员变量，一定要赋值（初始化）。而且不能修改。

​ 2.final可以修饰局部变量

​ 使用final修饰局部变量的时候，可以先对变量不赋值，使用之前进行赋值。

​ 但是一旦赋值以后就无法更改。

​ 3.final可以修饰成员方法

​ final修饰的成员方法不能被重写，牵涉到继承

​ 4.final可以修饰一个类

​ final修饰的类不能被继承

​ 5.final可以修饰对象的引用

​ 修饰对象引用 一旦被赋值 就无法改变

package com.qfedu.d_final;

 class Person {
	final String name = "狗蛋";
	
	public void test () {
		 final int i;
		i = 30;
		//i = 80;//一旦被赋值，就无法改变了
		System.out.println(i);
	}
	 public final void eat () {
		System.out.println("吃饭");
	}
}
//class Man extends Person {
//	@Override
//	public void eat() {
//		System.out.println("吃的多");
//	}
//}
public class Demo1 {
	public static void main(String[] args) {
		final Person person = new Person();
		System.out.println("Person:" + person);
		//一旦使用final修饰person 对象引用 是一个固定的内存地址
		Person person1 = new Person();
		System.out.println("Person1:"+ person1);
		//person.name = "嘻嘻";
		//person = person1;//将person1赋值给了person对象
		System.out.println(person);
	}

}

4.接口【重要】

4.1生活中的接口

USB

插座

起到一个扩展的功能

4.2Java中接口

语法格式：

interface  接口名字 {
	成员变量
    成员方法
}

实现接口使用关键字implements

package com.qfedu.e_interface;

interface A {
	//接口下面的属性都是常量   常量是使用static 和final修饰的
	//只不过在接口中把 static和fianls省去了 常量的名字都要大写
	String NAME = "狗蛋";
	//在接口一般不写属性的！！！
	//成员方法  在接口中全部是抽象的方法
	public void eat ();
	public void sleep();
	
}
//无法实例化接口A ，咋办？新建一个类去实现（implements）接口
class TestA implements A {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃好饭");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("睡好觉");
	}
	
}
public class Demo1 {
	public static void main(String[] args) {
		TestA testA = new TestA();
		testA.eat();
		testA.sleep();
		
		System.out.println(testA.NAME);
	}

}

接口的注意事项:

​ 1.使用关键字 interface 声明出来一个接口

​ 2.接口面可以有属性，但是是static 和final修饰的属性。被称为常量。几乎不用

​ 3.接口下面全部抽象的方法，不带方法体的

​ 4.jdk1.8以后是可以有默认（default）的方法的，这个默认方法带有方法体【重点！！！】

​ 5.接口下面没有构造方法，不能被实例化

​ 6.去使用一个普通的类去实现这个接口，使用关键字implements

​ 7.一定要在实现类中去实现所有的抽象方法

​ 8.一个普通的类可以实现多个接口，弥补了单继承的局限性

​ 9.一个接口可以去继承另外一个接口

package com.qfedu.e_interface;

interface B2 {
	public void work();
}
interface B1 extends B2{
	public void smoking();
}

interface A1 {
	String NAME = "狗蛋";
	
	
	public void test();
	public void eat();
	public default void sleep () {
		System.out.println("睡觉睡得啥也不知道");
	}
}
class TestA1 implements A1, B1{

	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("测试");
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃东西");
	}
	@Override
	public void sleep() {
		System.out.println("睡得什么都不会了");
	}

	@Override
	public void smoking() {
		// TODO Auto-generated method stub
		System.out.println("不要在整栋楼抽烟！！！");
	}

	@Override
	public void work() {
		// TODO Auto-generated method stub
		
	}
	
}
public class Demo2 {
	public static void main(String[] args) {
		TestA1 testA1 = new TestA1();
		testA1.eat();
		testA1.test();
		testA1.sleep();
	}

}

4.3案例

电脑类去实现以下的三个接口。

​ 电源接口

​ 鼠标接口

​ 网络接口

比如上面有三个接口，电脑是一个类，让电脑本身不具备插电源 连网线连鼠标的

只有在电脑类基础之上 去实现三个接口之后，那么电脑就会拥有充电 联网连鼠标这些功能的

package com.qfedu.e_interface;


//电源接口
interface Adapter {
	public void input();//充电
}
//USB 接口 连接鼠标
interface USB {
	public void mouse();
}
//网络接口   可以联网
interface Net {
	public void internet();
}
class Computer implements Adapter, USB, Net{

	@Override
	public void internet() {
		// TODO Auto-generated method stub
		System.out.println("联网");
	}

	@Override
	public void mouse() {
		// TODO Auto-generated method stub
		System.out.println("连接鼠标");
	}

	@Override
	public void input() {
		// TODO Auto-generated method stub
		System.out.println("充电！！！");
	}
	
}
public class Demo3 {
	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.mouse();
		computer.input();
		computer.internet();
	}

}

4.4案例

假如学校有接待处。接待不同的人，有不同的方式。

身份	吃	住
学生	食堂	学生宿舍
老师	教师食堂	教师公寓
领导	招待所	招待所

理论上来讲，每个人都是以恶搞不同的额对象。实现各自的方法

咱们能归纳出来一个模板。让学生 老师 领导 都去实现这个模板。

package com.qfedu.e_interface;

interface Person {
	void eat();
	void sleep();
	
}
class Stdudent implements Person {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("在学生食堂......");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("在宿舍睡觉");
		
	}
	
}
class Teacher implements Person {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("在教师食堂。。。。。。");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("在教师公寓。。。。。。");
	}
	
	
}
class Leader implements Person {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("招待所吃。。。");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("在招待所。。。。");
	}
	
}
public class Demo4 {
	public static void main(String[] args) {
		//实例化三个对象，调用方法即可
	}

}

作业：

1.列一个纲要，自己往里面填东西

2.知乎和CSDN 要写一篇博客（是咱们学过的知识点例如 继承详解）

3.书面作业

1、定义一个抽象的"Role"类，有姓名，年龄，性别等成员变量

1)要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)，

再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法，

该方法不返回任何值，同时至少定义两个构造方法。Role类中要体现出this的几种用法。

2)从Role类派生出一个"Employee"类，该类具有Role类的所有成员(构造方法除外)，

并扩展salary成员变量，

同样要有至少两个构造方法，要体现出this和super的几种用法，还要求覆盖play()方法，

并提供一个final sing()方法。

3)"Manager"类继承"Employee"类，有一个final成员变量"vehicle"

在main()方法中制造Manager和Employee对象,并测试这些对象的方法。





2、创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法，
* 使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承，
* 并在这两个类中实现NoOfWheels方法。在Car类中，应当显示“四轮车”信息；
* 而在Motorbike类中，应当显示“双轮车”信息。创建另一个带main方法的类，
* 在该类中创建Car和Motorbike的实例，并在控制台中显示消息。

3.编写步骤：

   1. 定义抽象类A，抽象类B继承A，普通类C继承B
    2.A类中，定义成员变量numa，赋值为10，抽象showA方法。
    3.B类中，定义成员变量numb，赋值为20，抽象showB方法。
    4.C类中，定义成员变量numc，赋值为30，重写showA方法，打印numa，重写showB方法，打印numb，定义showC方法，打印numc。
    5.测试类中，创建C对象，调用showA方法，showB方法，showC方法。

4.编写步骤：

    模拟农学院动物医疗系统信息。
    定义抽象家禽类(Poultry)
        私有成员变量：动物种类(name)，症状(symptom)，年龄(age)， 病因（illness）
        提供空参和带参构造方法
        成员方法：
            抽象方法症状(showSymptom)
            普通方法基本信息(showMsg)
            提供setXxx和getXxx方法
    定义普通鸭子类(Duck)
        提供空参和带参构造方法
        重写showSymptom方法，打印症状信息

5.编写步骤：

    模拟教学管理系统师生信息。
    定义Person类。
        属性：姓名、年龄
        构造方法：无参构造方法，有参构造方法
        成员方法：getXxx方法，setXxx方法，显示基本信息showMsg方法
    定义Teacher类，继承Person
        属性：学科
        构造方法：无参构造方法，有参构造方法
        成员方法：getXxx方法，setXxx方法，讲课方法
    定义Student类，继承Person
        属性：分数
        构造方法：无参构造方法，有参构造方法
        成员方法：getXxx方法，setXxx方法，考试方法