一、抽象类
(一)抽象类:包含抽象方法的类称为抽象类。
抽象类也要被abstract修饰,抽象类中可以有非抽象方法,抽象类不能创建实例对象。
abstract class Animal {
public abstract void bark();//抽象方法
public void fun(){
System.out.println("abstract Animal.fun()");
}
}
(二)抽象方法:被abstract所修饰,在抽象类中不予以实现。
当有一个类继承了当前的抽象类后,需要实现当中的抽象方法。
如果不加访问修饰限定符,默认为public。
(三)抽象类的派生类:
(1)如果是普通方法,必须实现抽象类当中的抽象方法;
(2)如果是抽象方法,可以不实现基类的抽象方法。
abstract class Dog extends Animal {
public Dog() {
System.out.println("Dod() init");
}
public abstract void bark();
// public void bark() {
// System.out.println("Dog:wangwang");
// }
}
class LittleDog extends Dog {
public void bark() {
System.out.println("Dog:wangwang");
}
}
(四)问题1:
抽象类和普通类的区别:
(1)抽象类不能被实例化;
(2)抽象方法必须是public或protected,或者不写;
(3)抽象类被abstract所修饰;
(4)抽象方法不能在抽象类当中实现。
二、密封类
(一)密封类:当一个类被final所修饰的时候,当前类被称为密封类。
注意:1、该类不能作用于基类;
2、就算派生类也被final所修饰也不可以。
作用:防止有意的派生。
final class Person {
private String name;
private int age;
public Person() {
System.out.println("Person init()");
}
public void fun1() {
System.out.println("Person fun1()");
}
}
//Person不能被继承
//class Student extends Person {
//
//}
(二)密封方法:final
不能被重写。
/*
class Person {
private String name;
private int age;
public Person() {
System.out.println("Person init()");
}
public final void fun1() {//密封方法
System.out.println("Person fun1()");
}
}
class Student extends Person {
public final void fun1() {
System.out.println("Person fun1()");
}
}
*/
三、接口
(一)接口:
1、由interface定义;
2、属性默认为public static final;
3、方法默认为public abstract;
4、实现接口:implements。
interface A {//定义一个接口
public static final int AGE = 10;//属性 默认为public static final
public abstract void fun();//方法 默认为public abstract方法
//接口中全部都是抽象方法
// void fun2() {
//
// }
}
interface B {//定义一个接口
int AGE = 111;
void fun2();
}
注:1、在JAVA里,继承只是单继承
2、类实现接口必须实现接口中定义的方法
3、接口支持向上继承。
(二)Cloneable接口:空接口(标记接口)
注:实现Cloneable接口必须要重写Object的clone()方法。
public interface Cloneable {
}
问题2、这个空接口的设计有什么作用?
标记当前类可以进行clone,如果不实现这个接口JVM不能识别。
(三)Comparable接口
public interface Comparable<T> {
public int compareTo(T o);
}
//Comparable接口
package practise.abstractAndFinal;
import java.util.Arrays;
class Student1 implements Comparable<Student1>{
private String name;
private int age;
private double score;
public Student1(String name,int age,double score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student1{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
@Override
public int compareTo(Student1 o) {
// return age-o.age;
// return name.compareTo(o.name);//引用类型
return (int)(score - o.score);
//[Student1{name='li', age=22, score=77.7}, Student1{name='wang', age=21, score=88.8}, Student1{name='zhang', age=20, score=99.9}
}
}
/*
public interface Comparable<T> {
public int compareTo(T o);
}
*/
public class Test7_Comparable {
public static void main(String[] args) {
Student1[] students = new Student1[3];//对象数组
students[0] = new Student1("zhang",20,99.9);
students[1] = new Student1("wang",21,88.8);
students[2] = new Student1("li",22,77.7);
//根据年龄进行排序
/**
* 自定义类型进行排序
* 实现Compareable接口
* 实现compareTo()方法
*/
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
(四)Comparator接口
package practise.abstractAndFinal;
import java.util.Arrays;
import java.util.Comparator;
class Student2 {
private String name;
private int age;
private double score;
public Student2(String name, int age, double score) {
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student2{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
public class Test8_Comparator {
public static void main(String[] args) {
Student2[] students = new Student2[3];//对象数组
students[0] = new Student2("zhang",20,99.9);
students[1] = new Student2("wang",21,88.8);
students[2] = new Student2("li",22,77.7);
Arrays.sort(students, new Comparator<Student2>() {
/**
*接口不一定不能new
* Arrays.sort()排序的时候,用来传参
*/
@Override
public int compare(Student2 o1, Student2 o2) {
// return o1.getAge() - o2.getAge();
return (int)(o1.getScore() - o2.getScore());
// return o1.getName().compareTo(o2.getName());
}
});
System.out.println(Arrays.toString(students));
}
}
问题3、Comparable和Comparator的区别:
(1)Comparable作用在类内;Comparator在类外。
(2)内部方法:Comparable(compareTo);Comparator(compare)。