一.抽象类:
1.抽象类介绍
抽象方法的类
abstract 关键字;
抽象方法由abstract修饰,类需要由 abstract修饰
抽象方法在抽象类内部不予以实现
抽象方法不能被private修饰,默认为public的
abstract class Animal{
public abstract void bark();
public void fun(){
System.out.println("abstract Animal fun()");
}
}
abstract class Dog extends Animal{
public Dog(){
System.out.println("Dog:.............");
}
}
class LittleDog extends Dog{
public void bark() {
System.out.println("Dog:xiao.....");
}
}
Animal 被 absrract修饰,所以是抽象类,其中的fun()方法为普通方法,直接实现;
而public abstract void bark();为抽象方法,由abstract修饰,在这个抽象类中不予以实现,Dog继承了Animal,单被abstract修饰,所以也为抽象类,LittleDog 继承了 Dog
为普通类,所以要在其中实现它父类的抽象方法;
2.总结
即: (1).抽象类中可以有非抽象方法
(2).抽象类不能创建实例对象;
抽象类的派生类:
1.如果是普通类,必须实现抽象类的抽象方法
2.如果是抽象类,可以不实现基类的抽象方法
3.面试题:
抽象类和普通类的普别?
- 抽象类不能被实力化
- 抽象方法必须是public或者protected,或者不写
- 抽象类被,abstract所修饰
- 抽象方法不能在抽象类当中实现。
二.密封类:
当一个类,被final所修饰的时候,成为密封类;
final class Boys1 {
private String name;
private int age;
public Boys1() {
System.out.println("Boys1 init()");
}
public void fun1() {
System.out.println("Boys1 init().......");
}
}
注意的是:
1.该类不能作用于基类; (即不能派生子类)
- 就算派生类被final修饰,也不可以
作用:防止有意的派生。
密封方法: 密封方法不能被重写。
三 .接口
1.接口的介绍:
Java中只能单继承(接口主要解决单继承的局限问题)
interface 关键字所修饰;
接口中的属性:默认为:public static final
接口中的方法:默认为:public abstract
interface A{
public static final int age=1;
public abstract void fun();
}
interface A{
int age=1;
void fun();
}
上面两种写法表示的是一样的;
注意(接口和抽象类的区别):
1.接口内的方法,必须不能被实现(都是抽象方法) 而抽象类可以有部分非抽象方法;
2.抽象类只能继承一次,接口可以被实现或者继承多个
implements实现接口,A,必须实现方法
interface D extend A,B 不用实现方法
interface A{
public static final int age=1;
public abstract void fun();
}
interface B{
int age=2;
void fun2();
}
interface C extends A,B{
void fun3();
}
class D implements C{
public void fun(){
System.out.println("A.fun().");
}
public void fun2(){
System.out.println("B.fun2().");
}
public void fun3(){
System.out.println("C.fun3().");
}
}
接口继承接口时,可以实现多继承,interface C extends A,B C不用实现A,B中的方法,
class D implements C ,类D实现了接口C,关键字 implements,既要实现接口C中的方法,还必须要实现接口A,B中的方法(因为接口C继承A,B)
2.cloneable 接口:
class Money implements Cloneable{
double money=1.0;
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
class Man implements Cloneable{
private String name;
Money m;
public Man(String name){
this.name=name;
this.m=new Money();
}
@Override
protected Object clone() throws CloneNotSupportedException {
Man man1=(Man) super.clone();
man1.m=(Money)this.m.clone();
return man1;
}
}
public static void main1(String[] args)throws CloneNotSupportedException{
Man man1=new Man("001");
Man man2=(Man) man1.clone();
System.out.println(man1.m.money);
System.out.println(man2.m.money);
man1.m.money=2.0;
System.out.println(man1.m.money);
System.out.println(man2.m.money);
}
/*输出结果为:
1.0
1.0
2.0
1.0
*/
实现Clonable接口,并且需要重写Object的clone方法。
面试问题:
- 空接口,标记接口,请问这个空接口的设计有什么作用?
public interface Cloneable{
}
它是标记这个类可以进行克隆,如果不实现这个接口,JVM不能够识别。
3.Comparable接口:
class Student implements Comparable<Student>{
private String name;
private int age;
private double score;
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
@Override
public int compareTo(Student o) {
//return name.compareTo(o.name);
return (int)(score-o.score);
}
}
public class Test1031_3 {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("qwer", 22, 98);
students[1] = new Student("asd", 20, 48);
students[2] = new Student("zxc", 18, 68);
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
需要Student implements Comparable 接口,然后在类的内部重写public int compareTo(Student o)方法。
4.Comparator接口:
class Student {
private String name;
private int age;
private double score;
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("qwer", 22, 98);
students[1] = new Student("asd", 20, 48);
students[2] = new Student("zxc", 18, 68);
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//return o1.getAge()-o2.getAge();
//return (int) (o1.getScore()-o2.getScore());
return o1.getName().compareTo(o2.getName());
}
});
System.out.println(Arrays.toString(students));
}