复习（继承多态）final--抽象类--抽象方法--接口

继承

关键字：extends,用于实现继承关系
特点：子类可以重用父类的代码，成员变量和方法，构造器不能继承
super：表示父类对象的引用，可以用于调用父类中的变量，方法，构造器
一类只能继承一个类。不能多继承
**Object **：是所有的顶级父类tostring 和equals方法

多态

前提：必须有继承关系
发生类型转换；
方法的重写；子类重写父类的方法后
类型转换：
向上转型：子类型转换为父类型自动转换；
向下转型：父类型转换为子类型（前提先要向上转型之后），强转、可能会发生ClassCastException 。

final关键字

final可以修饰的内容：
成员变量：变为常量，只能在声明时赋值，之后不允许改变。
方法：
类：

//3.修饰类，该类不允许被继承
public final class Demo {
	//1.修饰常量，常量规范必须大写，必须初始化赋值
	private final int NUM=123;
	//2.修饰方法
	public final void test(){
		System.out.println(NUM);
	}
	
}

抽象类

使用abstract关键字修饰的类被称为抽象类。

/*
 * 抽象类
 * 1.抽象类 不允许创建对象
 *2.可以定义构造器，用于被子类构造调用
 *
 *使用场景：当一个类必须被继承才能使用时被定义成抽象类
 *抽象一般是高度抽象类，不允许创建 对象，不适合创建对象
 */
public abstract class Demo {

	private int num;
	public Demo(){}
	public void test(){
		System.out.println("test方法");
	}
}

抽象方法

/*
 * 抽象类
 * 1.抽象类 不允许创建对象
 * 2.可以定义构造器，用于被子类构造调用
 *
 *使用场景：当一个类必须被继承才能使用时被定义成抽象类
 *抽象一般是高度抽象类，不允许创建 对象，不适合创建对象
 */
public abstract class Animal {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	//abstract 修饰的方法是抽象方法，抽象方法：没有方法体，只有申明信息
	//要求子类必须重写父类中的抽象方法
	//抽象方法只能定义在抽象类中普通类无法定义抽象方法
	//使用场景：要求所有子类都要有的方法
	public abstract void shout();
}

抽象类和抽象方法的关系

抽象类中可以有抽象方法，也可以没有。
抽象方法必须被定义在抽象类中。

接口（interface）

接口是特殊的抽象类，接口里面都是抽象方法。

/**
 * 接口，接口中的成员：
 * 1.接口中不能定义构造器 ：接口中都是抽象方法没有方法体所有不能定义构造器 
 * 2.接口中不能创建对象
 * 3.成员变量：接口中所有成员变量都是public static final 修饰的
 * 		成员变量使用:因为成员变量是被public static 修饰的 只要 类名.常量名
 * 4,接口中的方法：都是抽象方法 都是public static 修饰的都是抽象方法
 * 5.实现接口必须要重写接口中的方法
 * 6.实现可以实现多个接口；原因接口定义方法，同名问题在重写时能解决
 * 7.单继承，多实现（用，隔开）
 * 8.当类既要继承父类又要实现接口时，要实现extends 进行继承
 */
public interface Demo {
	int NUM=23;
	void  demo();
}

接口的使用案例

模拟动物园中的一些场景，各种各样的动物i，饲养员，食物的接口
Animal.java

public abstract class Animal {

	private String name;

	public Animal() {
		super();
	}

	public Animal(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	//抽象方法，叫
	public abstract void shout();
	//吃
	public abstract void eat(Food food);
}

tiger.java

public class Tiger extends Animal {

	public Tiger() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Tiger(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	public void shout() {
		System.out.println("wooo");
	}
	public void eat(Food food) {
		System.out.println(this.getName()+"正在吃"+food.getName());
	}
}

sheep.java

public class Sheep extends Animal implements Food{
	
	public Sheep() {
		super();
	}
	public Sheep(String name) {
		super(name);
	}
	public void shout() {
		System.out.println("maama");
	}
	public void eat(Food food) {
		System.out.println(this.getName()+"正在吃"+food.getName());
	}
}

food.java

public interface Food {
	String getName();
}

feeder.java

public class Feeder {
	public static void main(String[] args) {
		//创建动物对象
		Tiger tiger=new Tiger("老虎");
		//准备食物创建事务对象
		Food food=new Sheep("小羊");
		//喂食
		tiger.eat(food);
		tiger.shout();
	}
}

接口和类的比较

接口和类都是一种数据类型，引用数据类型。
接口不能被创建对象的，
接口的使用，必须有一个类通过implements 进行实现；类如果被继承的话应该使用extends 关键字继承
类中可以有的成员：成员变量，构造器，方法
接口中的成员：常量，抽象方法

jdk1.8 接口中新特性

接口中可以定义有方法体的方法：
可以将方法定义为static ，应该通过接口名。方法名的方法调用，
还可以使用default 关键字声明方法，这种方法可以有方法体的方法
原因：在1.8之前接口中只能定义抽象方法，当抽象方法过多时，实现类中需要将所有的抽象的方法进行重写。1.8中可以定义带方法体符方法

比较器

内部比较器

comparable

public class Person implements Comparable{

	private int age;

	public int getAge() {
		return age;
	}

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

	public Person(int age) {
		super();
		this.age = age;
	}

	public Person() {
		super();
	}

	public int compareTo(Object o) {
		//向下转型
		Person p =(Person) o;
		//当前对象的年龄
		//this.age;
		//目标对象
		//p.age;
		return this.age-p.age;
	}
	
}

外部比较器

comparator

import java.util.Comparator;

public class StudentComparator implements Comparator<Student>{

	public int compare(Student o1, Student o2) {
		return o1.getName().compareTo(o2.getName());
	}
	/*public int compare(Object o1, Object o2) {
		//向下转型
		Student s1=null;
		if(o1 instanceof Student){
			s1=(Student) o1;
		}
		if(s1==null){
			System.out.println("类型不匹配");
			return -1;
		}
		Student s2=(Student)o2;
		return s1.getName().compareTo(s2.getName());
	}*/
}

public class Test {

	public static void main(String[] args) {
		Student student=new Student("zhangjie");
		Student student2=new Student("zhangjie");
		//创建比较器对象
		StudentComparator sc=new StudentComparator();
		int result = sc.compare(student, student2);
		if(result>0){
			System.out.println(student.getName()+">"+student2.getName());
		}else if(result==0){
			System.out.println(student.getName()+"="+student2.getName());
		}else{
			System.out.println(student.getName()+"<"+student2.getName());
		}
	}
}