day9 java基础（final关键字 抽象类 多态 接口）

---------------------------知识点1----------------------------------
/*
继承的代码体现：

由于继承中含有方法重写
所以父类的功能，就会被子类覆盖，
在某些情况下，不能让子类覆盖掉父类的功能
这个时候，针对这种情况，java就提供了一个关键字：final

final:最终的意思，常见可修饰类，方法，变量

*/

class Fu{
public final void show(){
System.out.println(“这里是绝密资料，任何人不得修改访问”);
}

}

class Zi extends Fu{
public void show(){
System.out.println(“这里是一堆垃圾”);
}

}

class ZiDemo{
public static void main(String [] args){

Zi z = new Zi();
z.show(); // 错误：Zi中的show()无法覆盖Fu中的show()
}

}
---------------------------知识点2----------------------------------

/*
final可以修饰，方法，变量

特点：
	final可以修饰类，该类被继承。
	final可以修饰方法，该方法不能被重写
	final可以修饰变量，该变量不能被重新赋值，因为这个变量是常量
	
常量：
	字面常量：
		"hello"，10， true
	自定义常量：
		final int x = 10；

*/

// final class Fu // 错误: 无法从最终Fu进行继承

class Fu{
public int num =10;
public final int num2 =20;
/*public final void show(){

}*/

}

class Zi extends Fu{
public void show(){
num2 = 30;
System.out.println(num);
System.out.println(num2); // 错误: 无法为最终变量num2分配值
}
}

class FinalDemo{
public static void main(String [] args){
Zi z = new Zi();
z.show();
}
}
---------------------------知识点3----------------------------------

/*
面试题：final修饰局部变量的问题

基本类型:基本类型的值不能发生变化
引用类型：引用类型的地址值不能发生变化，但是，
		  该对象的堆内存储的值可以改变

*/

class Student{
int age = 10;
}

class FinalTest{
public static void main(String [] args){
//创建对象1
//int age = 300;
Student s = new Student();
System.out.println(s.age);

s.age = 200;
System.out.println(s.age);

//创建对象2
final Student ss = new Student();
System.out.println(ss.age);
ss.age = 300;
System.out.println(ss.age);

// ss = new Student(); //错误: 无法为最终变量ss分配值

}

}
---------------------------知识点4----------------------------------

/*
final 修饰变量的初始化时机
A.被final修饰的变量只能赋值一次
B.在构造方法完毕前（非静态的常量）
*/
class Demo{
int num ;
final int num2 ;

{
	num2 =10;
}
public Demo(){
	num = 100;
	// 错误: 无法为最终变量num2分配值
	num2 = 200;
}

}

class FinalTest2{
public static void main(String [] args){
Demo d = new Demo();
System.out.println(d.num);
System.out.println(d.num2);
}
}
---------------------------知识点5----------------------------------

/*
多态:同一个对象（事物），在不同时刻体现出来的不同状态

多态的前提：
	1.要有继承关系
	2.要有方法重写
		其实没有也可以，但是没有就没有意义了。
		动物 d = new 猫();
		d.show()
		动物 d = new 狗();
		d.show();
	3.要有父类引用指向子类对象。
	父类 f =  new 子类；

多态中成员访问特点：
	1.成员变量
		编译看左边，运行看左边
	2.构造方法
		创建子类对象的时候，访问父类的构造方法，对父类的数据初始化。
	3.成员方法
		编译看左边，运行看右边
	4.静态方法
		编译看左边，运行看左边
		（静态和类相关，算不上重写，所以访问的还是左边的）
		
	注意：
		由于成员方法存在方法重写，所以运行看右边

---------------------------知识点7----------------------------------

*/
class Fu{
public int num = 10;

public void show(){
	System.out.println("show Fu");
}

public static void function(){
	System.out.println("function Fu");
}

}

class Zi extends Fu{
int num = 100;
int num2 = 20;

public void show(){
	System.out.println("show zi");
}

public void method(){
	System.out.println("method Fu");
}

public static void  function(){
	System.out.println("function zi");
}

}

class DuoTaiDemo{
public static void main(String [] args){
Fu f = new Zi();
System.out.println(f.num);
f.show();
f.function();
//f.method(); // 错误: 找不到符号
// 找不到符号
//System.out.println(f.num2);

}

}
---------------------------知识点8----------------------------------

/*
多态的好处：
1.提高了代码的维护性（继承保证）
2.提高了代码的扩展性(多态保证)
*/
class Animal{
public void eat(){
System.out.println(“eat”);
}
public void sleep(){
System.out.println(“sleep”);
}
}

class Dog extends Animal{
public void eat(){
System.out.println(“狗吃骨头”);
}

public void sleep(){
	System.out.println("狗站着睡觉");
}

}

class Cat extends Animal{
public void eat(){
System.out.println(“猫吃鱼”);
}

public void sleep(){
	System.out.println("猫趴着睡觉");
}

}

class Pig extends Animal{
public void eat(){
System.out.println(“猪吃白菜”);
}
public void sleep(){
System.out.println(“猪躺着睡觉”);
}
}

// 针对动物的操作类
class AnimalTool{
private AnimalTool(){}
// 创建猫类使用方法
public static void useAnimal(Animal a){
a.eat();
a.sleep();
}
/*public static void useCat(Cat c){
c.eat();
c.sleep();
}

//创建狗类使用方法 
public static void  useDog(Dog d){
	d.eat();
	d.sleep();
}

// 创建猪类使用方法
public static void  usePig(Pig p){
	p.eat();
	p.sleep();
}*/

}

class DuoTaiDemo2{
public static void main(String [] args){
// 创建狗对象
Dog d = new Dog();
//DuoTaiDemo2.useDog(d);
AnimalTool.useAnimal(d);
d.eat();
d.sleep();
System.out.println("---------------");

	Dog d2 = new Dog();
	//DuoTaiDemo2.useDog(d2);
	d2.eat();
	d2.sleep();
	System.out.println("---------------");
	
	// 创建猫对象
	Cat c = new Cat();
	
	c.eat();
	c.sleep();
	System.out.println("---------------");
	
	Cat c2 = new Cat();
	c2.eat();
	c2.sleep();
	System.out.println("---------------");
	
	// 创建狗对象
	
	Pig p = new Pig();
	AnimalTool.useAnimal(p);

}

/*
// 创建猫类使用方法
public static void  useCat(Cat c){
	c.eat();
	c.sleep();
}

//创建狗类使用方法 
public static void  useDog(Dog d){
	d.eat();
	d.sleep();
}*/

}
---------------------------知识点10----------------------------------

/*
多态的弊端：
不能使用子类中的特有功能。
*/

class Fu{

public void show(){
	System.out.println("show Fu");
}

}

class Zi extends Fu{
public void show(){
System.out.println(“show Zi”);
}

public void method(){
	System.out.println("method Zi");
}

}

class DuoTaiDemo3{
public static void main(String [] args){

	Fu f = new Zi();
	f.show();
	// f.method(); 编译看左边，父类方法中没有method方法，
}

}
---------------------------知识点11----------------------------------

/*
多态的弊端：
不能使用子类中的特有功能。

使用子类的特有功能方法：
	1.创建子类对象，调用方法(可以，但是不合理，且占内存)
	2.把父类的引用强制转换成子类的引用（向下转型）
	
对象间的转型问题：
	向上转型：
		Fu f = new Zi();
	向下转型：
		Zi z = (Zi)f; // 要求f必须是能够转换为Zi的。

*/

class Fu{

public void show(){
	System.out.println("show Fu");
}

}

class Zi extends Fu{
public void show(){
System.out.println(“show Zi”);
}

public void method(){
	System.out.println("method Zi");
}

}

class DuoTaiDemo4{
public static void main(String [] args){

	Fu f = new Zi();
	f.show();
	// f.method(); 编译看左边，父类方法中没有method方法，
	
	// 创建子类对象
	//Zi z  = new Zi();
	//z.show();
	//z.method();
	//super.method();
	
	//把父类的引用赋值给子类的引用
	Zi z = (Zi)f;
	z.show();
	z.method();
}

}
---------------------------知识点12----------------------------------

/*
向上转型和向下转型中的一些问题
ClassCastException 类型转换异常 一般在多态向下转换中出现

*/
class Animal{
public void eat(){
System.out.println(“Animal eat”);
}
}

class Cat extends Animal{
public void eat(){
System.out.println(“猫吃东西”);
}
public void playGame(){
System.out.println(“猫玩游戏”);
}
}

class Dog extends Animal{
public void eat(){
System.out.println(“狗吃东西”);
}
public void lookDoor(){
System.out.println(“狗看门”);
}
}

class DuoTaiDemo5{
public static void main(String [] args){
// 多态实现
Animal a = new Cat();
a.eat(); // 可以理解为同样是调用父类方法，只是后来方法被重写成子类的数据，所以输出为子类的方法
// a.playGame(); 找不到符号，因为Animal中没有playGame()方法
Cat c = (Cat)a; // 将父类引用向下转型，意思是将引用a的值给c，让引用c指向猫类对象
c.eat();
c.playGame();

//创建狗对象
a = new Dog();
a.eat();
// a.lookDoor(); 找不到符号，因为父类Animnl中没有该方法
Dog d = (Dog)a;
d.eat();
d.lookDoor();

Cat cc = (Cat)a; // 类转换异常，报错 java.lang.ClassCastException: Dog cannot be cast

}

}
---------------------------知识点13----------------------------------

/*
猫狗案例：
*/
class Animal{
public void eat(){
System.out.println(“吃饭”);
}
}

class Cat extends Animal{
public void eat(){
System.out.println(“猫吃东西”);
}
public void playGame(){
System.out.println(“猫玩游戏”);
}
}

class Dog extends Animal{
public void eat(){
System.out.println(“狗吃东西”);
}
public void lookDoor(){
System.out.println(“狗看门”);
}
}

class DuoTaiTest{
public static void main(String [] args){
// 多态实现
Animal a = new Cat();
a.eat();
System.out.println("--------------------");
// 将a的地址值给c，让c指向new Cat()对象
Cat c = (Cat)a;
c.eat();
c.playGame();
System.out.println("--------------------");

//创建狗对象
a = new Dog();
a.eat();
System.out.println("--------------------");
//将a的地址值给d，让引用d指向new Dog();
Dog d = (Dog)a;
d.eat();
d.lookDoor();
System.out.println("--------------------");

// 


}

}
---------------------------知识点14----------------------------------

/*
不同地方的饮食文化不同案例
*/
class Person{
public void eat(){
System.out.println(“吃饭”);
}
}

class SouthPerson extends Person{
public void eat(){
System.out.println(“炒菜，吃米饭”);
}

public void jingShang(){
	System.out.println("经商");
}

}

class NorthPerson extends Person {
public void eat(){
System.out.println(“炖菜，吃馒头”);
}

public void yanJiu(){
	System.out.println("研究");
}

}

class DuoTaiTest2{
public static void main(String [] args){
// 南方人测试
Person p = new SouthPerson();
p.eat();
System.out.println("-------------");
SouthPerson sp = (SouthPerson) p;
sp.eat();
sp.jingShang();
System.out.println("-------------");

	//北方人测试
	p = new NorthPerson();
	p.eat();
	System.out.println("-------------");
	NorthPerson np = (NorthPerson)p;
	np.eat();
	np.yanJiu();
}

}
---------------------------知识点15----------------------------------

/*
使用多层继承方法，打印出“我爱你！”
*/

class A{
public void show(){
show2();
}

public void show2(){
	System.out.println("我");
}

}

class B extends A{
/public void show(){
show2();
}/

public void show2(){
	System.out.println("爱");
}

}

class C extends B{
public void show(){
super.show();
}

public void show2(){
	System.out.println("你！");
}

}

// 测试类
class DuoTaiTest3{
public static void main(String [] args){
// 创建对象
A a = new A();
a.show();
a = new B();
a.show();
a = new C();
a.show();

//C c = new B();
//c.show();

}

}
---------------------------知识点16----------------------------------

/*
抽象类的概述
动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的
我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类

抽象类的特点：
	1.抽象类和抽象方法必须用abstract关键字修饰
	2.抽象类中不一定有抽象方法，但是有抽象方法的类定义必须为抽象方法
	3.抽象类不能实例化
		因为它不是具体的
		抽象类有构造方法，但是不能实例化，构造方法有什么作用
		用于子类访问父类的数据的初始化
	4.抽象的子类
		1.如果不想所有抽象方法重写，该子类是一个抽象方法
		2.重写所有的抽象方法，这个时候子类是一个具体的类
	
	抽象类的实例化，是靠具体的子类的具体化，其实是靠多态来实现。
	Animal a = new Cat();

*/

abstract class Animal{
//抽象fangfa
//public abstract void eat(){}; // 空方法
public abstract void eat();

public Animal(){}

}

//abstract
//class Dog extends Animal{} // Dog不是抽象的, 并且未覆盖Animal中的抽象方法eat()
abstract class Dog extends Animal{}

class Cat extends Animal{
public void eat(){
System.out.println(“猫吃鱼”);
}
}

class AbstractDemo{
public static void main(String [] args){
// 创建对象
// Animal是抽象的，无法实例化
//Animal a = new Animal();
Animal a = new Cat();
a.eat();

}

}
---------------------------知识点17----------------------------------

/*
抽象类的成员特点：
成员方法：既可以是常量，也可以是常量
构造方法：有。
用于子类访问父类数据的初始化

	成员方法：既可以是抽象的，也可以是非抽象的
	
抽象类的成员方法特性：
	1.抽象方法 强制要求子类做的事情。
	2.非抽象方法 子类继承的事情，提高了代码的复用性

*/

abstract class Animal{
public int num = 10;
public final int num2 = 100;

public Animal(){}

public Animal(String name,int age){}

public abstract void show();

public void method(){
	System.out.println("method");
}

}

class Dog extends Animal{
public void show(){
System.out.println(“方法重写”);
}
}

class AbstractDemo2{
public static void main(String [] args){
// 创建对象
Animal a = new Dog();
a.num = 200;
System.out.println(a.num);

//a.num2 = 120; //错误: 无法为最终变量num2分配值
System.out.println(a.num2);

//a.show(); //错误: Dog不是抽象的, 并且未覆盖Animal中的抽象方法show()
a.show();
a.method();

}
}
---------------------------知识点18----------------------------------

/*
猫狗案例
具体事物：猫，狗
共性：姓名，年龄，吃饭

分析：从具体到抽象
	猫：
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：吃饭（猫吃鱼）
		
	狗：
		成员变量： 姓名，年龄
		构造方法：无参，带参
		成员方法： 吃饭（狗吃肉）

实现：从抽象到具体

*/
abstract class Animal{
// 姓名
private String name;
// 年龄
private int age;

// 无参构造方法
public Animal(){}

// 带参构造方法
public Animal(String name,int age){
	this.name = name;
	this.age = age;
}

public void setName(String name){
	this.name = name;
}

public String getName(){
	return name;
}

public void setAge(int age ){
	this.age = age;
}

public int  getAge(){
	return age;
}
public abstract void eat();

}

// 创建猫类
class Cat extends Animal{
//无参构造方法
public Cat(){}

// 带参构造方法
public Cat(String name,int age){
	super(name,age);
}

// 重写父类抽象方法
public void eat(){
	System.out.println("猫吃鱼");
}

}

class AbstractTest{
public static void main(String [] args){
// 创建猫对象 方式1
Cat c = new Cat();
c.setName(“Tom”);
c.setAge(20);
System.out.println(c.getName()+"—"+c.getAge());
c.eat();
System.out.println("---------------------------");

// 创建猫对象（多态）方式2
Animal a = new Cat();
a.setName("Tom");
a.setAge(20);
System.out.println(a.getName()+"---"+a.getAge());
a.eat();
System.out.println("---------------------------");

// 创建猫对象（多态）方式3
Animal a1 = new Cat("Tom",20);
System.out.println(a1.getName()+"---"+a1.getAge());
a1.eat();
}

}
---------------------------知识点19----------------------------------

/*
老师案例
具体事物：基础班老师，就业办老师
共性：姓名，年龄，讲课
*/
abstract class Teacher{
// 姓名
private String name;

// 年龄
private int age;

// 无参构造方法
public Teacher(){}

// 带参构造方法
public Teacher(String name,int age){
	this.name = name;
	this.age = age;
}

// 设置姓名方法
public void setName(String name){
	this.name = name;
}

// 获取姓名方法
public String getName(){
	return name;
}

// 设置年龄方法
public void setAge(int age){
	this.age = age;
}

//获取年龄方法
public int getAge(){
	return age;
}

// 讲课方法
public abstract void teach();

}

class BaseTeacher extends Teacher{
// 创建无参构造方法
public BaseTeacher(){}

// 创建带参构造方法
public BaseTeacher(String name,int age){
	super(name,age);
}

// 教课方法
public void teach(){
	System.out.println("基础班老师教课");
}

}

class WorkTeacher extends Teacher{
// 创建无参构造方法
public WorkTeacher(){}

// 创建带参构造方法
public WorkTeacher(String name,int age){
	super(name,age);
}

// 教课方法
public void teach(){
	System.out.println("就业班老师教课");
}

}

class AbstractTest2{
public static void main(String [] args){

// 创建基础班老师
// 基础班老师 方式1 直接创造子类对象
BaseTeacher b = new BaseTeacher();
b.setName("张三");
b.setAge(20);
System.out.println(b.getName()+"------"+b.getAge());
b.teach();
System.out.println("----------------");

//基础班老师 方式2 通过子类构造方法直接设置成员变量
BaseTeacher b1 = new BaseTeacher("张三",20);
System.out.println(b1.getName()+"------"+b1.getAge());
b1.teach();
System.out.println("----------------");

// 基础班老师 方式3 通过多态实现
Teacher t = new BaseTeacher();
t.setName("张三");
t.setAge(20);
System.out.println(t.getName()+"------"+t.getAge());
t.teach();
System.out.println("----------------");

// 基础班老师 方式4 通过多态实现,通过子类构造方法对成员变量赋值
t = new BaseTeacher("张三",20);
System.out.println(t.getName()+"------"+t.getAge());
t.teach();
System.out.println("----------------");

// 创建就业班老师
// 就业班老师 方式1 直接创造子类对象
WorkTeacher w = new WorkTeacher();
w.setName("李四");
w.setAge(28);
System.out.println(w.getName()+"------"+w.getAge());
w.teach();
System.out.println("----------------");

//就业班老师 方式2 通过子类构造方法直接设置成员变量
w = new WorkTeacher("李四",28);
System.out.println(w.getName()+"------"+w.getAge());
w.teach();
System.out.println("----------------");

// 就业班老师 方式3 通过多态实现
t = new WorkTeacher();
t.setName("李四");
t.setAge(28);
System.out.println(t.getName()+"------"+t.getAge());
t.teach();
System.out.println("----------------");

// 就业班老师 方式4 通过多态实现,通过子类构造方法对成员变量赋值
t = new WorkTeacher("李四",28);
System.out.println(t.getName()+"------"+t.getAge());
t.teach();
System.out.println("----------------");


}

}
---------------------------知识点20----------------------------------

/*
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

普通员工：
	成员变量：姓名 工号 工资
	构造方法：无参 带参
	成员方法：工作
	
经理：
	成员变量：姓名 工号 工资 奖金
	构造方法： 无参 带参
	成员方法：工作

抽象总结：
员工类：
成员变量：姓名 工号 工资
构造方法：无参 带参
成员方法：工作

*/

abstract class Employee{
// 姓名
private String name;

// 工号
private String job_number;

// 工资
private int wages;

// 无参构造方法
public Employee(){}

// 带参构造方法
public Employee(String name,String job_number,int wages){
	this.name = name;
	this.job_number = job_number;
	this.wages = wages;
}

// 设置姓名方法
public void setName(String name){
	this.name = name;
}

// 获取姓名方法
public String getName(){
	return name;
}

// 设置工号方法
public void setJob_number(String job_number){
	this.job_number = job_number;
}

// 获取工号方法
public String getJob_number(){
	return job_number;
}

// 设置工资方法
public void setWages(int wages){
	this.wages = wages;
}

// 获取工资方法
public int getWages(){
	return wages;
}

// 抽象工作方法
public abstract void work();  // 抽象方法也需要返回值类型

}

class Worker extends Employee{
// 无参构造方法
public Worker(){}

// 带参构造方法
public Worker(String name,String job_number,int wages){
	super(name,job_number,wages);
}

// 工作方法
public void work(){
	System.out.println("普通员工");
}

}

class Manager extends Employee{
// 奖金属性
private int bonus;

// 无参构造方法
public Manager(){}

// 带参构造方法
public Manager(String name,String job_number,int wages,int bonus){
	super(name,job_number,wages);
	this.bonus = bonus; // 这里可以将经理类的特有属性加入构造方法参数列表中，使用this.bouns格式
}

// 工作方法 
public void work(){
	System.out.println("经理");
}

// 设置奖金方法
public void setBonus(int bonus){
	this.bonus = bonus;
}

// 获取奖金方法
public int getBonus(){
	return bonus;
}

}

// 测试类
class AbstractTest3{
public static void main(String [] args){
// 具体类测试方法省略

	// 创建员工类
	// 采用多态方法，创建对象.
	// 使用无参构造
	Employee e = new Worker();
	e.setName("张三");
	e.setJob_number("x003");
	e.setWages(10000);
	e.work();
	System.out.println("姓名："+e.getName()+" 工号："+e.getJob_number()+" 工资："+e.getWages());
	System.out.println("---------------------------");
	
	// 使用带参构造
	e = new Worker("张三","x003",10000);
	e.work();
	System.out.println("姓名："+e.getName()+" 工号："+e.getJob_number()+" 工资："+e.getWages());
	System.out.println("---------------------------");
	
	// 创建经理类
	// 采用多态方法，创建对象.
	// 使用无参构造
	e = new Manager();
	e.setName("李四");
	e.setJob_number("x001");
	e.setWages(30000);
	e.work();
	Manager m = (Manager)e; // 向下转型
	m.setBonus(200000);
	System.out.println("姓名："+e.getName()+" 工号："+e.getJob_number()+" 工资："+e.getWages()+" 奖金："+m.getBonus());
	System.out.println("---------------------------");
	
	
	// 使用带参构造方法
    e = new Manager("李四","x001",30000,200000);
	e.work();
	// 访问经理类特有属性
	Manager m1 = (Manager)e; // 向下转型
	System.out.println("姓名："+e.getName()+" 工号："+e.getJob_number()+" 工资："+e.getWages()+" 奖金："+m1.getBonus());
	System.out.println("---------------------------");
	
	//m.setBonus(200000);
	//System.out.println("李经理的奖金是："+m.getBonus());
	//System.out.println("---------------------------");
	
}

}
---------------------------知识点21----------------------------------

/*
接口的特点：
1.接口关键字interface表示
interface 接口名{}
2.类实现接口用imploments表示
class 类名 implements 接口名{}
3.接口不能实例化
按照多态的方式来实例化

	由此可见：
		1.具体类多态（几乎没有）
		2.抽象类多态（常用）
		3.接口多态（最常用）
			a：可以是抽象类。但是意义不大
			b:	可以是具体类。重写接口中所有的抽象方法

*/
// 定义动物培训接口
interface AnimalTrain{
public abstract void jump();
}

// 抽象类实现接口
abstract class Dog implements AnimalTrain{

}

// 具体类实现接口
class Cat implements AnimalTrain{
public void jump(){
System.out.println(“猫可以跳高了”);
}
}

class InterfaceDemo{
public static void main(String [] ags){
//AnimalTrain at = new AnimalTrain();
//at.jump();
AnimalTrain at = new Cat();
at.jump();
}
}
---------------------------知识点22----------------------------------

/*
接口的成员特点：
成员变量：只能是常量，并且是静态的
默认修饰符：public static final
建议：自己手动给出
构造方法：接口没有构造方法。
成员方法：只能是抽象方法
默认修饰符：public abstract
建议：自己手动给出

所有类都默认继承自一个类Object。
类Object 是类层次结构的根类。每个类都使用Object作为超类。

*/
interface Inter{
public int num = 10;
public final int num2 = 20;
public static final int num3 = 30;

// 错误：需要标识符
//public Inter(){}

// 方法接口不能带主体
//public void show(){} 
//public abstract void show(); 默认是抽象方法

}

// 接口名+Impl这种格式是接口的实现类格式
/*class InterImpl implements Inter{
public InterImpl(){
super();
}
}
*/
class InterImpl extends Object implements Inter{
public InterImpl(){
super();
}

public void show(){}

}

class InterfaceDemo2{
public static void main(String [] args ){
// 创建对象
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
System.out.println("----------------");
//i.num = 30; // 错误: 无法为最终变量num分配值 接口中的成员变量默认为最终变量，不能被修改
//i.num2 = 40;// 错误: 无法为最终变量num2分配值
System.out.println(Inter.num);
System.out.println(Inter.num2);
System.out.println("----------------");
}
}
---------------------------知识点23----------------------------------

/*
类与类：
继承关系，只能单继承，可以多层继承
类与接口：
实现关系,可以单实现，也可以多实现
并且还可以在继承一个类的同时实现多个接口
接口与接口：
继承关系，可以单继承，也可以多继承
*/

interface Father{
public abstract void show();
}

interface Mother{
public abstract void show2();
}

class Son extends Object implements Father,Mother{ // 多实现的方式
public void show(){
System.out.println(“show son”);
}

public void show2(){
	System.out.println("show mother");
}

}

class InterfaceDemo3{
public static void main(String [] args){
// 创建对象
Father f = new Son();
f.show();
//f.show2(); 报错

	Mother m = new Son();
	//m.show(); 报错
	m.show2();
}

}
---------------------------知识点24----------------------------------

/*
猫狗案例，加入跳高的额外功能

分析： 从抽象到具体
	猫：
		姓名 年龄
		吃饭 睡觉
	狗：
		姓名 年龄
		吃饭 睡觉
	由于有共性功能

*/
interface Inter{

public abstract void jum();

}

abstract class Animal{
// 私有成员变量
// 姓名
private String name;

// 年龄
private int age;

// 无参构造方法
public Animal(){}

// 带参构造方法
public Animal(String name,int age){
this.name = name;
this.age = age;
}

// 设置姓名
public void setName(String name){
this.name = name;
}

// 获取姓名
public String getName(){
return name;
}

// 设置年龄
public void setAge(int age){
this.age = age;
}

// 获取年龄
public int getAge(){
return age;
}

// 吃饭方法
public abstract void eat();

// 睡觉方法
public abstract void sleep();

}

// 创建猫类
class Cat extends Animal implements Inter{
// 无参构造方法
public Cat(){}

// 带参构造方法
public  Cat(String name,int age){
	super(name,age);
}

public void eat(){
	System.out.println("猫吃鱼");
}

public void sleep(){
	System.out.println("猫趴着睡觉");
}

public void jum(){
	System.out.println("狗可以跳高了");
}

}

// 创建狗类
class Dog extends Animal implements Inter{
// 无参构造方法
public Dog(){}

// 带参构造方法
public Dog(String name,int age){
	super(name,age);
}

public void eat(){
	System.out.println("狗吃肉");
}

public void sleep(){
	System.out.println("狗躺着睡觉");
}

public void jum(){
	System.out.println("猫可以跳高了");
}

}

class InterfaceTest{
public static void main(String [] args){
// 创建猫对象 方式1
Cat c = new Cat();
c.setName(“Tom”);
c.setAge(20);
c.eat();
c.sleep();
c.jum();
System.out.println(c.getName()+"----"+c.getAge());
System.out.println("---------------------------");

// 创建猫对象 方式2
Cat c2 = new Cat("Tom",20);
c2.eat();
c2.sleep();
c2.jum();
System.out.println(c2.getName()+"----"+c2.getAge());
System.out.println("---------------------------");

// 创建猫对象 方式3
Animal a = new Cat();
a.setName("Tom");
a.setAge(20);
a.eat();
a.sleep();
Cat c3 = (Cat)a;
c3.jum();
System.out.println(a.getName()+"----"+a.getAge());
System.out.println("---------------------------");

// 创建猫对象 方式4
a = new Cat("Tom",20);
a.eat();
a.sleep();
Cat c4  = (Cat)a;
c4.jum();
System.out.println(a.getName()+"----"+a.getAge());
System.out.println("---------------------------");

// 创建狗对象 方式1
Dog d = new Dog();
d.setName("旺财");
d.setAge(12);
d.eat();
d.sleep();
d.jum();
System.out.println(d.getName()+"----"+d.getAge());
System.out.println("---------------------------");

// 创建狗对象 方式2
Dog d2 = new Dog("旺财",12);
d2.eat();
d2.sleep();
d2.jum();
System.out.println(d2.getName()+"----"+d2.getAge());
System.out.println("---------------------------");

// 创建狗对象 方式3
Animal a1 = new Dog();
a1.setName("旺财");
a1.setAge(12);
a1.eat();
a1.sleep();
Dog d3 = (Dog)a1;
d3.jum();
System.out.println(a1.getName()+"----"+a1.getAge());
System.out.println("---------------------------");

// 创建狗对象 方式4
a1 = new Dog("旺财",12);
a1.eat();
a1.sleep();
Dog d4  = (Dog)a1;
d4.jum();
System.out.println(a1.getName()+"----"+a1.getAge());
System.out.println("---------------------------");

}

}
---------------------------知识点25----------------------------------

/*
猫狗案例改进版：跳高猫属于猫类的一种，在猫中只有部分猫回跳高

猫狗案例，加入跳高的额外功能

分析： 从抽象到具体
	猫：
		姓名 年龄
		吃饭 睡觉
	狗：
		姓名 年龄
		吃饭 睡觉

*/
// 额外功能接口
interface Inter{

public abstract void jum();

}

// 抽象类方法
abstract class Animal{
// 私有成员变量
// 姓名
private String name;

// 年龄
private int age;

// 无参构造方法
public Animal(){}

// 带参构造方法
public Animal(String name,int age){
this.name = name;
this.age = age;
}

// 设置姓名
public void setName(String name){
this.name = name;
}

// 获取姓名
public String getName(){
return name;
}

// 设置年龄
public void setAge(int age){
this.age = age;
}

// 获取年龄
public int getAge(){
return age;
}

// 吃饭方法
public abstract void eat();

// 睡觉方法 因为动物睡觉都相同，故定义为非抽象方法
public void sleep(){};
}

// 创建具体猫类
class Cat extends Animal{
// 无参构造方法
public Cat(){}

// 带参构造方法
public Cat(String name, int age){
super(name,age);
}

//吃饭方法重写
public void eat(){
System.out.println(“猫吃鱼”);
}
}

// 创建跳高猫类
class JumpingCat extends Cat implements Inter{
// 无参构造方法
public JumpingCat(){}

// 带参构造方法
public JumpingCat(String name, int age){
super(name,age);
}
public void jum(){
System.out.println(“猫可以跳高啦！”);
}

}

// 创建具体狗类
class Dog extends Animal{
// 无参构造方法
public Dog(){}

// 带参构造方法
public Dog(String name, int age){
super(name,age);
}

//吃饭方法重写
public void eat(){
System.out.println(“狗吃肉”);
}
}

// 创建跳高狗类
class JumpingDog extends Cat implements Inter{
// 无参构造方法
public JumpingDog(){}

// 带参构造方法
public JumpingDog(String name, int age){
super(name,age);
}
public void jum(){
System.out.println(“狗可以跳高啦！”);
}

}

class InterfaceTest2{
public static void main(String [] args){
// 创建对象 省略具体实现类的两种方式

	// 创建猫对象 方式1
	JumpingCat jc = new JumpingCat();
	jc.setName("Tom");
	jc.setAge(20);
	jc.jum();
	System.out.println(jc.getName()+"---"+jc.getAge());
	System.out.println("----------------------------");
	
	// 创建猫对象 方式2
	JumpingCat jc2 = new JumpingCat("Tom",20);
	jc2.jum();
	System.out.println(jc2.getName()+"---"+jc2.getAge());
	System.out.println("----------------------------");

	// 创建狗对象 方式1
	JumpingDog jd = new JumpingDog();
	jd.setName("旺财");
	jd.setAge(10);
	jd.jum();
	System.out.println(jd.getName()+"---"+jd.getAge());
	System.out.println("----------------------------");
	
	// 创建猫对象 方式2
	JumpingDog jd2 = new JumpingDog("旺财",10);
	jd2.jum();
	System.out.println(jd2.getName()+"---"+jd2.getAge());
	System.out.println("----------------------------");
}

}
---------------------------知识点26----------------------------------

抽象类和接口的区别：
1.成员区别
抽象类：
成员变量：可以变量，也可以是常量
构造方法：有
成员方法：可以是抽象也可以是非抽象
接口：
成员变量：只可以是常量
成员方法：只可以是抽象方法

2.关系区别
	类与类
		继承 单继承 
	类与接口
		实现 单实现 多实现
	接口与接口 继承 单继承 多继承
	
3.设计理念的区别
	抽象类，被继承体现是：is a的理念。抽象类中定义的是该类继承体系的共性功能
	接口  被实现体现的是 like a 的关系 接口定义的是该继承体系的扩展功能。