抽象类
抽象类的概念有人会觉得有些抽象，下面我将彻头彻尾的介绍抽象类的概念及其应用 我们先来看下面这组代码
在刚才的例子中, 我们发现，父类 Shape 中的 draw 方法好像并没有什么实际工作，主要的输出都是由Shape 的各种子类的 draw 方法来完成的。像这种没有实际工作的方法，我们可以把它设计成一个抽象方法，包含抽象方法的类我们称之为抽象类。
abstract class Shapes{
public abstract void draw();
}
1.在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码). 2.对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类。
注意事项：
- 1.用关键字abstract进行修饰
- 2.在抽象类中，可以有普通类的所有属性
- 3.和普通类不一样的地方是：包含了抽象方法
- 4.不能被实例化：不能new
- 5.主要作用就是被继承
- 6.不能用final修饰
- 7.不能是私有的，不能是static的
- 8.只要是有一个类，继承了这个抽象类，那么必须重写抽象类中的方法
下面来看一下代码的执行应用：
abstract class Shapes{
public abstract void draw();
}
class Cycles extends Shapes{
@Override
public void draw(){
System.out.println("这是一个圆");
}
}
class Rects extends Shapes{
@Override
public void draw(){
System.out.println("这是一个矩形");
}
}
public class TextDemo3 {
public static void main(String[] args) {
Shapes[] shapes2 = {new Cycles(), new Rects()};
for (Shapes shape : shapes2) {
shape.draw();
}
}
}
输出结果： 这是一个圆 这是一个矩形
抽象类主要的作用是继承，需要注意的是，继承后必须在子类的里面进行重写！！
接口
接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。
下面是接口的具体实现方法
interface Shape{
void draw();//有几个这种方法，下面重写多少个
}
class Cycle implements Shape{
@Override
public void draw(){
System.out.println("这是一个圆");
}
}
class Rect implements Shape {
@Override
public void draw(){
System.out.println("这是一个矩形");
}
}
public class TestDemo1 {
public static void main(String[] args) {
Shape shape1 = new Cycle();
shape1.draw();
}
}
注意事项
1.使用 interface 定义一个接口 2.接口中的方法一定是抽象方法, 因此可以省略 abstract 3.接口中的方法一定是 public, 因此可以省略 public 4.Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现” 5.在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例. 6 接口不能被实例化 7 在接口中不能定义已经实现的方法 8 实现了该接口，一定重写该接口中的方法 9 接口和接口之间可以通过extends进行联系
补充：
1.接口中的方法都是抽象方法 2.其实可以有具体实现的方法（再jdk1，8加入的）,方法前面加上default：（一般情况不用） default public void func(){} 3.接口中定义的成员变量默认为常量 ，需要初始化 4.接口中的成员变量，默认为public static final 接口中的成员方法默认为： public abstract 5.接口是不可以用来实例化 6.接口和类之间的关系为implements 7.解决java中的单继承问题，可以实现多个接口 8.只要这个类实现了该接口，那么你就可以进行向上转型
实现多个接口（可以实现多继承）
多个接口的实现可以配合继承来完成，该类连接了有几个接口，就要重写多少个方法
下面是完整代码
class Animal{
public String name;
public Animal(String name){
this.name = name;
}
}
interface Flying{
void fiy();
}
interface Jumping{
void jup();
}
interface Swimming{
void swim();
}
class Dog extends Animal implements Swimming{
public Dog(String name){
super(name);
}
@Override
public void swim() {
System.out.println(this.name +"会游泳");
}
}
class Bird extends Animal implements Jumping,Flying{
public Bird(String name){
super(name);
}
@Override
public void fiy() {
System.out.println(this.name +"会飞");
}
@Override
public void jup() {
System.out.println(this.name + "会跳");
}
}
public class MoreImp {
public static void jum(Jumping jumping){
jumping.jup();
}
public static void swim(Swimming swimming){
swimming.swim();
}
public static void fly(Flying flying){
flying.fiy();
}
public static void main(String[] args) {
Dog dog = new Dog("露露");
swim(dog);
Bird bird = new Bird("huahua");
fly(bird);
jum(bird);
}
}
接口使用示例（综合）
如果想比较一串数字的大小，并且从小到大输出，我们自然想到了以下函数
Arrays.sort();
但是如果想比较一个学生的分数、姓名等属性，应该怎么去写呢，下面是完整代码
自定义比较用Comparable或者Comparator接口
import java.util.Arrays;
//**自定义比较用Comparable接口**
class Student implements Comparable<Student>{
public String name;
public int age;
public int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
@Override
public int compareTo(Student o) {
if(this.age<o.age){
return -1;
}
if (this.age==o.age){
return 0;
}
return 1;
}
//或者是以下几种
// return this.age - o.age;//根据年龄从小到大（前面跟后面比）
//return this.score - o.score;//根据分数从小到大
//return this.name.compareTo(o.name);//字符串的比较大小
}
public class TestDemocracy {
public static void main(String[] args) {
Student[] student = new Student[3];
student[0] = new Student("bit",10,32);
student[1] = new Student("bi",13,38);
student[2] = new Student("b",14,34);
Arrays.sort(student);//比较
System.out.println(Arrays.toString(student));
}
}
其中：其中Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法，这样就可以实现几个对象属性的比较大小