1.抽象类

定义：抽象方法：这个方法没有具体的实现；

抽象类：不能完全代表一个具体的对象。

注意：

1> 使用 abstract 修饰；

2> 抽象类不能进行实例化，但普通类可以；

3> 抽象类中不一定包含抽象方法，但包含抽象方法的类一定是抽象类；

4> 抽象类中可以定义普通的成员变量和成员方法；

5> 抽象类存在的最大意义就是为了被继承，且多了一层编译器的校验；

6> 普通类继承抽象类后要重写抽象类中的抽象方法；

7> 抽象类A继承抽象类B后不需要重写，但当普通类C再继承抽象类A后，要重写所有没被重写的抽象方法；

8> 要满足重写的要求（如static和private不能被重写）；

9> final关键字不可能和abstract同时作用在一个类或方法上；

10> 抽象类当中可以存在构造方法，在子类实例化时，会帮助父类的成员进行初始化。

abstract class Shape { //抽象类public int a;//普通成员变量public void print() { //普通成员方法System.out.println("Shape");}public abstract void draw(); //抽象方法
}
class Cycle extends Shape { //普通类@Override //普通类继承抽象类后要重写抽象类中的抽象方法public void draw() {System.out.println("○");}
}
abstract class Flower extends Shape {//抽象类继承抽象类，可以不重写父类的抽象方法abstract public void printf();//抽象方法
}
class Square extends Flower {@Override //见注意事项6public void draw() {System.out.println("□");}@Overridepublic void printf() {System.out.println("❀");}
}

2.接口

定义：对公共行为的规范标准，是一种引用数据类型。相当于抽象类的进一步抽象。

注意：

1> 使用 interface 定义；

2> 接口中不能有实现的方法，但是静态方法和被default修饰的方法可以实现；

3> 接口中的成员方法默认是public abstract修饰的；

4> 接口中的成员变量默认是public static final 修饰的；

5> 不能通过关键字new来实例化；

6> 类和接口之间使用implement进行关联；

7> 类实现接口后要重写接口中的抽象方法；

8> 接口中存在default方法时可重写可不重写，具体看业务需求；

9> 不论是接口还是抽象类，都有向上转型；

10> 子类实现接口方法时，这个方法一定要public修饰；

11> 接口中没有构造方法和代码块；

12> 当一个类不想实现接口当中的方法时，这个类可以被定义为抽象类；

13> 接口的修饰符可以为abstract、public，不能为protected、private、final。

interface IShape { //接口//成员方法默认为public abstract修饰，顾下列方法均为抽象方法public abstract void draw1();//抽象方法不可实现，public abstract可省略public void draw2();//抽象方法不可实现，public可省略public static void draw3() { //静态方法可以实现System.out.println("draw3");}default public void draw4() { //被default修饰的方法可以实现System.out.println("draw4");}
}
class Cycle implements IShape { //Cycle类实现了IShape接口@Override //重写接口中的抽象方法public void draw1() {System.out.println("○");}@Override //重写接口中的抽象方法public void draw2() {System.out.println("□");}
}
class Rect implements IShape { //同上@Overridepublic void draw1() {System.out.println("□");}@Overridepublic void draw2() {System.out.println("○");}
}
public class Test {public static void drawMap(IShape shape) { //多态shape.draw1();}public static void main(String[] args) {//IShape iShape = new IShape();//接口无法实例化自己IShape iShape1 = new Cycle();IShape iShape2 = new Rect();//向上转型drawMap(new Cycle());drawMap(new Rect());}
}

2.1实现多个接口

意义：一个类实现多个接口，可以解决Java中多继承的问题。

注意：先继承类，再实现接口。

interface IFlying { //接口1void fly();
}
interface ISwimming { //接口2void swim();
}
interface IRunning { //接口3void run();
}
abstract class Animal { //抽象父类public String name;public int age;public Animal(String name, int age) { //带两个参数的构造方法this.name = name;this.age = age;}public abstract void eat(); //抽象方法
}
class Dog extends Animal implements IRunning,ISwimming{ //子类1public Dog(String name, int age) { //子类的构造方法super(name, age);}@Override //重写父类和接口的抽象方法public void swim() {System.out.println(this.name+"正在狗刨");}@Overridepublic void run() {System.out.println(this.name+"正在跑");}@Overridepublic void eat() {System.out.println(this.name+"正在吃狗粮");}
}
class Bird extends Animal implements IFlying { //子类2public Bird(String name, int age) { //子类的构造方法super(name, age);}@Override //重写父类和接口的抽象方法public void fly() {System.out.println(this.name+"正在飞");}@Overridepublic void eat() {System.out.println(this.name+"正在吃虫子");}
}
public class Test {public static void testEat(Animal animal) { //多态animal.eat();}public static void testFly(IFlying iFlying) { //多态iFlying.fly();}public static void testRun(IRunning running) { //多态running.run();}public static void testSwim(ISwimming iSwimming) { //多态iSwimming.swim();}public static void main(String[] args) {testEat(new Bird("小鸟",3));testEat(new Dog("小狗",3));testFly(new Bird("小小鸟",2));testRun(new Dog("小小狗",2));testSwim(new Dog("小小小狗",1));}
}

2.2接口之间的关系

接口与接口之间关联用 extends，意为拓展，非继承。相当于把接口合并在一起。

interface A {void testA();
}
interface B {void testB();
}
interface C extends A,B { //此时C接口不仅有自己的功能，还有A接口和B接口的功能void testC();
}
class D implements C { //ABC中的抽象方法都要重写@Overridepublic void testA() {}@Overridepublic void testB() {}@Overridepublic void testC() {}
}

2.3接口使用实例

2.3.1Comparable接口

//只根据年龄或成绩比较：

import java.util.Arrays;
class Student implements Comparable<Student>{ //当对自定义类型进行比较时，一定要实现可比较的接口public String name;public int age;public double score;public Student(String name, int age, double score) { //带三个参数的构造方法this.name = name;this.age = age;this.score = score;}@Override //重写Comparable接口中的抽象方法public int compareTo(Student o) { //按年龄排序/*if (this.age - o.age > 0) {return 1;} else if (this.age - o.age == 0) {return 0;}else {return -1;}*/return this.age - o.age;}
}
public class Test {//模拟实现冒泡排序public static void bubbleSort(Comparable[] comparables) { //传入Comparable类型(实现了可比较接口)的数组for (int i = 0; i < comparables.length-1; i++) {for (int j = 0; j < comparables.length-1-i; j++) {//if (comparables[j]>comparables[j+1]) //无法直接比较if(comparables[j].compareTo(comparables[j+1]) > 0) { //使用重写的compareTo方法比较Comparable tmp = comparables[j];comparables[j] = comparables[j+1];comparables[j+1] = tmp;}}}}public static void main(String[] args) {Student[] array = new Student[2];array[0] = new Student("zhangsan",20,88.8);array[1] = new Student("lisi",18,90);bubbleSort(array); //冒泡排序System.out.println("排序后："+Arrays.toString(array));}public static void main2(String[] args) {Student student1 = new Student("xiaoming",14,98.5);Student student2 = new Student("xiaohong",16,59.9);int ret = student1.compareTo(student2);System.out.println(ret); //-1}public static void main1(String[] args) {Student[] array = new Student[3];array[0] = new Student("zhangsan",20,88.8);array[1] = new Student("lisi",18,90);array[2] = new Student("wangwu",21,68.9);System.out.println("排序前："+ Arrays.toString(array));Arrays.sort(array); //Java自带的方法System.out.println("排序后："+ Arrays.toString(array));}
}

2.3.2Comparator接口

//年龄成绩均可比较：更加灵活

import java.util.Comparator;
class Student{public String name;public int age;public double score;public Student(String name, int age, double score) {this.name = name;this.age = age;this.score = score;}
}
class AgeComparator implements Comparator<Student> { //比较年龄@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}
}
class ScoreComparator implements Comparator<Student> { //比较成绩@Overridepublic int compare(Student o1, Student o2) {return (int)(o1.score - o2.score);//score为double类型，需要强转为int类型}
}
public class Test {public static void main(String[] args) {Student student1 = new Student("xiaoming",14,98.5);Student student2 = new Student("xiaohong",16,59.9);AgeComparator ageComparator = new AgeComparator();int ret = ageComparator.compare(student1,student2);System.out.println(ret);//-2ScoreComparator scoreComparator = new ScoreComparator();int ret2 = scoreComparator.compare(student1,student2);System.out.println(ret2);//38}
}

2.3.2Clone接口

class Student implements Cloneable { //实现Cloneable接口public int age;public Student(int age) {this.age = age;}@Overridepublic String toString() {return "Student{" +"age=" + age +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException { //异常return super.clone();//子类重写的Object只是调用了父类的clone方法}
}
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student1 = new Student(18);Student student2 = (Student) student1.clone();//向下转型，clone类型为Object，需强转为StudentSystem.out.println(student1);//Student{age=18}System.out.println(student2);//Student{age=18} 克隆成功}
}

Ctrl+点击进入Cloneable接口后发现，该接口内什么东西都没有，why？？

答：这个接口被叫做标记接口，实现该接口证明当前的类是可以被克隆的。

//浅拷贝

class Money {public double money;
}
class Student implements Cloneable { 实现Cloneable接口public int age;public Money m = new Money();public Student(int age) {this.age = age;}@Override //重写接口中的抽象方法protected Object clone() throws CloneNotSupportedException { return super.clone();}
}
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student1 = new Student(18);student1.m.money = 9.15;Student student2 = (Student) student1.clone();//克隆student1System.out.println(student1.m.money);//9.15System.out.println(student2.m.money);//9.15student1.m.money = 10;//更改student1System.out.println(student1.m.money);//10 按理说只有student1变System.out.println(student2.m.money);//10 但是实际上两个都变了//这就是浅拷贝，没有克隆当前对象内更深层的变量}
}

//深拷贝

class Money implements Cloneable { //实现Cloneable接口public double money;@Override //重写接口中的抽象方法protected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Student implements Cloneable { //实现Cloneable接口public int age;public Money m = new Money();public Student(int age) {this.age = age;}@Override //重写接口中的抽象方法protected Object clone() throws CloneNotSupportedException {Student tmp = (Student) super.clone();//先克隆当前对象tmp.m = (Money) this.m.clone();//再克隆当前对象里更深层的变量return tmp;}
}
public class Test {public static void main(String[] args) throws CloneNotSupportedException {Student student1 = new Student(18);student1.m.money = 9.15;Student student2 = (Student) student1.clone();//克隆student1System.out.println(student1.m.money);//9.15System.out.println(student2.m.money);//9.15student1.m.money = 10;//更改student1System.out.println(student1.m.money);//10    深拷贝，只修改了student1System.out.println(student2.m.money);//9.15  不影响student2内的值}
}

2.4抽象类与接口的区别

区别	抽象类（abstract）	接口（interface）
结构组成	普通成员变量+抽象方法	抽象方法+全局变量
权限	各种权限	public
子类使用	使用extends继承抽象类	使用implement实现接口
关系	一个抽象类可以实现若干接口	借口不能继承抽象类，但可使用extends拓展多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口

Over！五一结束啦~~

【Java】抽象类接口相关推荐

JAVA抽象类接口初始化块实验_抽象类和接口 - 逝水无痕7777的个人空间 - OSCHINA - 中文开源技术交流社区...
抽象类和接口 1.抽象类抽象方法是只有方法签名,没有方法实现的方法.有抽象方法的类只能被定义成抽象类,抽象类可以没有抽象方法.抽象方法和抽象类必须使用abstract修饰符来定义. 抽象类不能被实例 ...
java抽象类接口举例代码_Java接口和抽象类实例分析
本文实例讲述了Java的接口和抽象类.分享给大家供大家参考.具体分析如下: 对于面向对象编程来说,抽象是它的一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类.这两者有太多相 ...
Java抽象类+接口详细图解一篇博客拿下
目录抽象类抽象类的概念抽象类的语法抽象类的特性抽象类的作用接口接口的概念接口的语法接口特性实现多个接口接口间的继承接口实例 1.Compareable 2.Comparator ...
Java抽象类/接口
一.抽象类: 1.关键字:abstract ;修饰抽象类,抽象方法: 2.注释: 2.1.抽象类不可以创建对象,但是可以被声明引用(强制被使用多态): 2.2.抽象类不一定包含抽象方法,包含抽象方法一 ...
Java接口和Java抽象类
Java接口和Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了. 1.Java接口和Java抽象类最大的一个区别,就在于Java ...
java 抽象类继承抽象类_Java之继承、抽象类、接口篇
一.继承(extends) 什么是继承? 继承是对现实生活中的"分类"概念的一种模拟. 狮子拥有动物的一切基本特性,但同时又拥有自己的独特的特性,这就是"继承" ...
Java接口和Java抽象类的认识
在没有好好地研习面向对象设计的设计模式之前,我对Java接口和Java抽象类的认识还是很模糊,很不可理解. 刚学Java语言时,就很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有 ...
Java抽象类与接口的区别
很多常见的面试题都会出诸如抽象类和接口有什么区别,什么情况下会使用抽象类和什么情况你会使用接口这样的问题.本文我们将仔细讨论这些话题. 在讨论它们之间的不同点之前,我们先看看抽象类.接口各自的特性. ...
IEnumeratorTItem和IEnumerator Java 抽象类和普通类、接口的区别——看完你就顿悟了...
IEnumerable 其原型至少可以说有15年历史,或者更长,它是通过 IEnumerator 来定义的,而后者中使用装箱的 object 方式来定义,也就是弱类型的.弱类型不但会有性能问题,最主要 ...
java 抽象接口类,Java接口(interface)和Java抽象类(abstract class)的区别（详诉版）
1.概述一个软件设计的好坏,我想很大程度上取决于它的整体架构,而这个整体架构其实就是你对整个宏观商业业务的抽象框架, 当代表业务逻辑的高层抽象层结构合理时,你底层的具体实现需要考虑的就仅仅是一些算法 ...

【Java】抽象类接口

1.抽象类

2.接口

2.1实现多个接口

2.2接口之间的关系

2.3接口使用实例

2.3.1Comparable接口

2.3.2Comparator接口

2.3.2Clone接口

2.4抽象类与接口的区别

【Java】抽象类接口相关推荐

最新文章

热门文章