目录
- 1.抽象类
- 1.1什么是抽象类
- 1.2抽象类语法
- 1.3抽象类与普通类的区别
- 2.抽象类的特性
- 2.1 特性
- 2.2抽象类的作用
- 3.接口
- 3.1什么是接口
- 3.2语法规范
- 3.3接口的使用
- 3.4接口的特性
- 3.5 实现多个接口
- 3.6 接口的继承
- 4.接口的实例
- 5.Clonable 接口和深拷贝
- 5.1 浅拷贝
- 5.2深拷贝
- 6. 抽象类和接口的区别
1.抽象类
1.1什么是抽象类
在我们Java面对对象的概念中，所有的对象都是通过类来描述的，但是有一些对象不能通过类来描述。
如果一个类中没有足够的系信息去描绘一个具体的对象，这个类就是抽象类。
说明:
1.Animal是动物类，每个动物都有叫的方法，但由于Animal不是一个具体的动物，因此其内部eat()方法无法具体实现
2.Dog是狗类，首先狗是动物，因此与Animal是继承关系，其次狗是一种具体的动物，狗叫:汪汪汪，其eat()可以实现
3.Cat是猫类，首先猫是动物，因此与Animal是继承关系，其次猫是一种具体的动物，猫叫:崛瞄瞄，其eat()可以实现
4.因此:Animal可以设计为“抽象类"
我们可以看出来，父类的eat（）方法，并不是一个实际的工作，主要的各种子类的eat（）方法来实现的，像这种没有实际工作的方法，我们一般可以设为一个抽象方法。包含抽象方法的类称为抽象类。
1.2抽象类语法
如果一个类，被abstract修饰，那么这个类就是一个抽象类，这个类中，被abstract修饰的方法，称为抽象方法。
注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法
abstract class A
{abstract public void func();}
class B extends A
{@Overridepublic void func() {System.out.println("B的方法");}
}
public class Test {public static void main(String[] args) {A a=new B();a.func();}
}
1.3抽象类与普通类的区别
1.抽象类不能实例化，普通类可以实例化
2.抽象类中，可以包含抽象方法和普通方法，但是普通类只能包含非抽象方法。
2.抽象类的特性
2.1 特性
1.抽象类使用abstract修饰类
2.抽象类不能被实例化。
3.此时在抽象类当中，可以有抽象方法，或者非抽象方法!
4.什么是抽象方法，一个方法被abstract修饰，没有具体的实现。只要包含抽象方法，这个类必须是抽象类!
5.当一个普通类继承了这个抽象类，必须重写抽象类当中的抽象方法!
6.抽象类存在的最大的意义，就是为了被继承!
7.抽象方法不能被private , final , static修饰。所以一定要满足方法重写的规则!!
8.当一个子类没有重写抽象的父类的方法，可以把当前子类变为abstract修饰。
9.抽象类中，不一定包含抽象方法
2.2抽象类的作用
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
确实如此. 但是使用抽象类相当于多了一重编译器的校验.
使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.
3.接口
3.1什么是接口
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型
3.2语法规范
我们接口的定义跟类差不多，就是把class换位interface关键字，就可以定义了一个接口。
interface IShape{public int age=2;public String name="1";//默认是这个public static final String sex="1";//方法默认这个public abstract void draw();//也可以default public void func(){System.out.println("66666666");}public static void staticfunc(){System.out.println("staticfunc");}
}
注意:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
3.3接口的使用
接口不能直接的使用，必须要有一个类来实现这个接口，实现接口中的抽象方法
子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
public class 类名称 implements 接口名称{
// ...
}
public class Mouse implements USB{@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}public void click(){System.out.println("点击鼠标");}
}
3.4接口的特性
大家如果想用这个东西你必须实现一下我的规范。
1.使用关键字interface来定义接口
2.接口不能被实例化
3.接口当中的成员默认是public static final
4.接口当中的方法不写也是默认为public abstract的
5.接口当中的方法不能有具体的实现，但是从JDK8开始可以写一个default修饰的方法
6.接口当中不能有构造方法
7.接口需要被类实现，使用关键字implements
8.接口当中可以有static修饰的方法!
9. 重写接口中方法时，不能使用默认的访问权限
10.接口中不能有静态代码块和构造方法
3.5 实现多个接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。
下面通过类来表示一组动物.。
并且在定义几个接口表示跑，游泳，飞等等。
接下来我们创建几个具体的动物，具体实现这几个接口
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
abstract class Animal {public String name;public Animal(String name) {this.name = name;}
}
interface IRunning {void run();
}
interface ISwimming {void swim();
}interface IFly {void fly();
}class Dog extends Animal implements IRunning {public Dog(String name) {super(name);}@Overridepublic void run() {System.out.println(name +" 正在用四条狗腿跑！");}
}class Fish extends Animal implements ISwimming{public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(name + "正在游泳！");}
}
class Bird extends Animal implements IFly {public Bird(String name) {super(name);}@Overridepublic void fly() {System.out.println(name + "正在飞！");}
}
class Duck extends Animal implements IRunning,IFly,ISwimming {public Duck(String name) {super(name);}@Overridepublic void run() {System.out.println(name + "正在用两条腿跑！");}@Overridepublic void swim() {System.out.println(name + "正在用两条腿在游泳！");}@Overridepublic void fly() {System.out.println(name + "正在用翅膀飞！");}
}class Robot implements IRunning{@Overridepublic void run() {System.out.println("机器人在用机器腿跑步！");}
}public class Test4 {/*** 只要实现了 IRunning 接口的 都可以接收* @param iRunning*/public static void walk(IRunning iRunning) {iRunning.run();}public static void swim(ISwimming iSwimming) {iSwimming.swim();}/*** 一定是一个动物* @param animal*/public static void func(Animal animal) {}public static void main(String[] args) {walk(new Dog("旺财"));walk(new Duck("唐老鸭"));walk(new Robot());System.out.println("======");swim(new Fish("七秒"));swim(new Duck("唐老鸭2号"));}
}
这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.
3.6 接口的继承
在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
4.接口的实例
当我们定义了一个Stydent类，里面定义了两个属性，一个姓名，一个年纪。
当我们 new 了三个对象的时候，我们想给他排序，这应该怎么办？当我们只用原本的sort（）方法会发现报错。
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable
那么我们应该怎么办？当我们的对象里面有两个属性，这个时候我们不会知道按照那个属性去排序，就会出现错误。
所以我们就要重写方法，让这个方法按照我们想排序的属性去进行比较。
package demo3;import java.util.Arrays;
import java.util.Comparator;class 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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", 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 o1.score-o2.score;}
}class Namecomparator implements Comparator<Student>
{@Overridepublic int compare(Student o1, Student o2) {return o1.name.compareTo(o2.name);}
}
public class test {public static void main(String[] args) {Student[] students=new Student[3];students[0]=new Student("zhangsan",10,10);students[1]=new Student("lisi",20,20);students[2]=new Student("wangwu",30,30);Agecomparator getcomparator=new Agecomparator();Arrays.sort(students,getcomparator);System.out.println(Arrays.toString(students));System.out.println("===========");Scorecomparator scorecomparator=new Scorecomparator();Arrays.sort(students,scorecomparator);System.out.println(Arrays.toString(students));System.out.println("===============");Namecomparator namecomparator=new Namecomparator();Arrays.sort(students,namecomparator);System.out.println(Arrays.toString(students));}
}
5.Clonable 接口和深拷贝
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常
5.1 浅拷贝
class Money
{public double money=12.25;}
class Student implements Cloneable
{public String name;public Money m=new Money();@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class test {public static void main(String[] args) throws CloneNotSupportedException {Student student=new Student();student.name="123";Student student1=(Student) student.clone();System.out.println(student);System.out.println(student1);System.out.println("==========");student1.m.money=99;System.out.println(student.m.money);System.out.println(student1.m.money);}
}
如上代码，我们可以看到，通过clone，我们只是拷贝了Student对象。但是Student对象中的Money对象，并
没有拷贝。通过Student1这个引用修改了m的值后，Student1这个引用访问m的时候，值也发生了改变。这里
就是发生了浅拷贝。
5.2深拷贝
package demo4;class Money implements Cloneable
{public double money=12.25;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Student implements Cloneable
{public String name;public Money m=new Money();@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {Student student=(Student) super.clone();student.m=(Money)this.m.clone();return student;//return super.clone();}
}
public class test {public static void main(String[] args) throws CloneNotSupportedException{Student student=new Student();Student student1=(Student) student.clone();System.out.println(student.m.money);System.out.println(student1.m.money);System.out.println("=============");student1.m.money=99;System.out.println(student.m.money);System.out.println(student1.m.money);}public static void main1(String[] args) throws CloneNotSupportedException {Student student=new Student();student.name="123";Student student1=(Student) student.clone();System.out.println(student);System.out.println(student1);}
}
如上代码，我们可以看到，通过clone，我们只是拷贝了Student对象。并且Student对象中的Money对象也进行了拷贝。通过Student1这个引用修改了m的值后，Student个引用访问m的时候，值也发生了改变。这里
就是发生了深拷贝。
6. 抽象类和接口的区别
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法,子类必须重写所有的抽象方法.
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。
