java接口与抽象类,java抽象类和接口的理解

　　00-1010什么是抽象类抽象类语法总结抽象类：如何定义接口接口继承几个重要的接口接口comparablecomparator接口-comparator可克隆接口深刻理解深拷贝和浅拷贝如何使用可克隆接口轻拷贝：深拷贝

　　class { public void draw(){ system . out . println(我要画图形！);}} classcircle扩展shape { @ override public void draw(){ system . out . println(我要画一个圆！);}} ClassRect扩展Shape { @ override public void draw(){ system . out . println(我要画一个矩形！);} }公共类test demo 3 { public static void draw Shape(Shape Shape){ Shape . draw()；}公共静态void main(String[]args){ draw shape(new circle())；draw shape(new rect())；}}}只是通过这个小案例来回顾一下多态性，我们创建一个Shape父类，然后创建两个子类，分别是rect类和circle类，然后用这两个类使用相同的方法，产生了不同的形式。这是多态性，但是

　　可以发现我只用这两个子类来画图形，分别是圆形和矩形。我没有调用父类来实现这个方法。为什么？因为这个父类不能画图形，实现这个父类的draw方法不是没用吗？我只需要它的父类中有这个方法，通过它的子类重写就可以了，不需要父类的方法的任何具体实现。

　　没错，这就是我们今天引入的话题抽象类。

　　上面父类的draw方法根本没用，不用写了，正好符合抽象类的定义。当没有足够的信息来描述它时，我们称之为抽象类。

　　00-1010上面父类的draw方法，没有具体实现，可以称为抽象方法。用抽象来装饰

　　公共抽象void draw()；

　　但是为什么这是错的呢？

　　原因是抽象修改的方法叫抽象方法。如果一个类中有抽象方法，那么这个类一定是抽象的，所以这个类也要用抽象来修改。

　　相反，抽象类中有抽象方法吗？

　　编译器不会报错，所以答案不一定。抽象类中可能有也可能没有抽象方法。

　　抽象类可以实例化吗？

　　因此，抽象类不能被实例化。

　　抽象类可以像普通类一样定义成员变量和方法，构造方法吗？

　　抽象类和普通类的区别在于抽象类不能实例化，其他成员变量、成员方法、构造方法等等的定义都是一样的。

　　既然抽象类不能实例化，那它们存在的意义是什么？

　　铁老的思维有道理。其实抽象类最大的意义就是被继承，因为抽象类不能实例化对象，只能依靠子类重写父类(也就是抽象类)来完成业务需求。

　　如何继承抽象类？有哪些注意点？

　　为什么继承会出错？原因是当子类继承抽象类时，子类需要重写父类的所有方法或者子类需要用abstract修饰(抽象类被抽象类继承或者子类重写抽象类(父类)的所有方法)。

　　没错。

　　注意，当我们不覆盖父类的方法时，我们用abstract修改它。这时，当你继承了这个子类，也就是这个子类成为了父类，下一个子类会继续覆盖这个父类的方法和这个父类的父类的方法。

　　抽象方法的装饰可以不同于static和final吗？

　　抽象方法不能被static 和final 修饰，因为子类要重写父类的方法，同时可以省略访问修饰限定符，默认是public。

总结抽象类：

我们把不能足够描述清楚一个对象的类叫做抽象类。被abstract修饰的方法称为抽象方法，被abstract修饰的类称为抽象类抽象方法必须在抽象类里面，也就是说，只要有抽象方法，类名也必须利用abstract来修饰，相反，抽象类里面可以没有抽象方法，也可以有抽象方法。抽象类不能实例化，除了不能实例化之外其他与普通类一样可以定义成员变量，成员方法，构造方法等。同时构造方法和类方法(被static修饰的方法)不能被abstract来修饰抽象方法的访问修饰限定符不能是private，如果省略默认是public，同时抽象方法不能被final修饰。子类继承抽象类的时候，子类必须重写抽象类的所有方法并且要有方法的具体实现，如果重写那子类还是抽象类，必须用abstract来修饰。抽象类中的方法没有具体实现，要通过子类重写在子类中实现。一个类只能继承一个抽象类

接口

说到接口我们会想到什么呢？？？我一开始想到的就是充电接口插排等等，比如充电接口，只要符合那个插口的标准，我们都可以使用那个接口来进行充电。这就是把标准进行统一起来，然后大家就可以根据不同的标准来使用不同的接口，比如苹果手机与安卓手机的手机接口就是不一样的，他们就是两种不同的标准，安卓手机用安卓的接口，苹果用苹果的接口这就将标准统一起来。

　　而在Java中也是一样的，我们把这个标准或者可以说是一种公共的规范叫做接口，只要符合这一接口的标准我们就可以使用它。

　　听着这抽象的概念你可能现在还是不太明白这到底是什么，我在来拿代码举个例子：

class Animal { public String name; public int age; public void eat() { System.out.println(this.name+"吃饭***！"); }}

这里我定义了一个动物类，这个动物有名字，年龄，还有吃饭的行为。

class Animal { public String name; public int age; public void eat() { System.out.println(this.name+"吃饭***！"); } public void swim() { System.out.println("我要游泳~~~~"); }}class Fish extends Animal {}

接着我又定义了一个鱼类(子类)继承这个动物类(父类)，我想让这个鱼有这个游泳的行为，但是这就会有一个问题，在父类定义了一个swim方法，接着我还要定义很多类，难道所有的类都要有这个游泳的行为么？？？答案是不可以的。所以我们就不能把这个swim方法定义在父类里面，那我们就可以把这个方法定义在子类(鱼类)里面，这样就符合了，但是如果我还要定义1000个动物都会游泳难道都要在自己类中写这个游泳的方法么？？这样做显然是不可行的。那我们该怎么做呢？？

　　我们可以就提供一个公共的接口，这也是一种标准，只要符合这一标准都可以使用这个接口或者可以说可以实现这一功能。

　　看了上面的引例我们应该接口是干什么的了，接下来我们来学一下接口的语法。

怎么定义接口

定义接口要使用interface关键字：

//创建一个接口//创建接口要是用interface关键字 接口的命名最好是形容词其他的也可以interface IFlying{ //这就是一个flying接口}

接口中的成员变量：

　　这样会报错，接口中的成员变量都是常量，所以必须初始化，接口中的成员变量会被隐式指定为public static final 修饰的。

interface IFlying{ //接口中的成员变量默认都是被public static final修饰的常量 //这里的成员变量不可改变 public static final int a =10;}

接口中的成员方法：

interface IFlying{ //接口中的成员方法都是抽象方法，默认是public abstract //其中public abstract 可以被省略 //接口中的成员方法不能有具体的实现 public abstract void eat(); //一般就写成： //void eat(); default void sleep(){ //接口中的方法想要具体实现，要加上default修饰 } //接口中可以有静态方法的具体实现 public static void method() { System.out.println("我是静态的方法!!"); }}

接口能否实例化？？？

　　接口是不能被实例化的。

　　怎么使用接口？？？

　　实现的接口如下：

interface IFlying{ void eat();}interface IRunning{ void run();}interface ISwimming{ void swim();}interface IClimbing{ void climb();}

//创建一个Ant类 //利用implements关键字来实现接口//一个类可以实现多个接口，接口之间利用逗号连接//实现了接口必须要在接口中重写接口中的方法//重写方法快捷键：鼠标移动到implements关键字上然后 alt+enterclass Ant implements IClimbing,IRunning{ public String name; @Override public void run() { System.out.println(this.name+"要跑步"); } @Override public void climb() { System.out.println(this.name+"爬山"); }}

接口的使用时利用implements关键字与类连接，类与接口之间使用implements连接的。一个类可以实现多个接口，多个接口之间利用逗号连接。class Ant implements IClimbing,IRunning.的意思是类Ant可以实现两个功能，既可以爬又可以跑。类实现接口时，必须要重写接口中的方法。如果不重写该类还是抽象类，要用abstract来修饰。接口能否有静态方法和代码块呢？？？

　　接口中是不能有静态代码块和构造方法的。

接口间的继承

我们这里总结一下类与接口之间的联系

　　类与类之间是继承关系利用extends来连接代表子类继承了父类类与接口之间是利用implements来连接，代表类能实现某个功能接口与接口之间也可以进行联系，利用extends 接口A和接口B interface A enxtends B 代表接口A拓展了接口B的功能。这里来讲一下接口与接口之间的继承

　　我们利用extends关键字将两个接口连接起来，这样就实现了接口之间的继承。

　　例如：

interface IRunning extends IFlying{ //类IRunning拓展了IFlying的功能 void run(); //接口与接口之间继承后IRunning拓展了IFlying功能 //有了IRunning的功能的类也要重写IFlying这个方法}

类IRunning拓展了IFlying的功能接口与接口之间继承后IRunning拓展了IFlying功能有了IRunning的功能的类也要重写IFlying这个方法

几个重要的接口

接口comparable

我们这里举一个例子：

　　比如我们要进行给一个学生进行排序，我们之前学过Arrays的sort方法，好我们来尝试一下这个方法对学生进排序。

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; } @Override public String toString() { return "Student{" + "name=" + name +  + ", age=" + age + ", score=" + score + }; }}public class TestDemo { public static void main(String[] args) { Student[] student = new Student[4]; student[0] = new Student("张三",18,88); student[1] = new Student("李四",98,98); student[2] = new Student("王二麻子",8,18); student[3] = new Student("赵老八",58,38); System.out.println(Arrays.toString(student)); Arrays.sort(student); System.out.println(Arrays.toString(student)); }}

　　从这里发现Arrays.sort方法是比较具体的数字大小的，而我们这里比较学生这个对象并没有指定,我们究竟依靠什么来比较这个学生对象，目前这个学生有名字，分数，年龄，我们到底依靠什么比较是根据我们的需求来定，那我们要具体的比较学生对象的某一个学生怎么比较呢·？？？看报错信息也就是这个异常，我们需要提供这个comparable这个接口然后重写这个comparable方法。

　　怎样提供接口？？？？

　　我们根据类要实现一个接口是利用关键字implements来连接的。

　　然后使用comparable这个接口,尖括号里面写上你要排序的类。

　　好这样我们就实现了这个接口，当然看前面那个红线就知道会有报错，这也就是当我们实现一个接口我们必须重写这个接口中的方法，然后Alt+enter重写这个接口中的方法。

　　好，我们就重写了这样的一个方法，比如我们要比较年龄按照升序排列：

　　然后调用Arrays.sort方法就可以进行排序了。

　　同样我们还可以根据名字排序：

　　由于，名字是String类型也就是引用类型所以我们要调用compareTo方法来进行比较。

　　同样的我们还可以根据分数来排序这个学生对象。

comparator接口-比较器

我们刚才使用comparable这个接口会有一个缺陷，就比如当我们已经实现按照年龄排序好了，但是有个人突然把他改成了名字比较，如果是未来做项目开发的时候，那就会给程序猿造成很大的困扰，就怕有一天别人修改了那段代码，所以我们就有了这个comparator这个比较器，我们还是把他封装起来，不用在去学生这个类中去修改。

　　对学生年龄排序：

class AgeComparator implements Comparator<Student>{ @Override public int compare(Student o1, Student o2) { return o1.age - o2.age; }}

对学生分数排序：

class ScoreComparator implements Comparator<Student>{ @Override public int compare(Student o1, Student o2) { return (int)(o1.score - o2.score); }}

对学生名字排序：

class NameComparator implements Comparator<Student>{ @Override public int compare(Student o1, Student o2) { return o1.name.compareTo(o2.name); }}

我们还是利用Arrays.sort方法里面再加一个比较器的这个参数就可以比较了。

 public static void main(String[] args) { Student[] student = new Student[4]; student[0] = new Student("张三",18,88); student[1] = new Student("李四",98,98); student[2] = new Student("王二麻子",8,18); student[3] = new Student("赵老八",58,38); System.out.println(Arrays.toString(student)); AgeComparator ageComparator = new AgeComparator(); Arrays.sort(student,ageComparator); System.out.println(Arrays.toString(student)); }

这样我们将根据什么排序，实例化对应的对象，通过对象调用重写comparator的方法就可以进行比较，不需要担心类中被修改。

cloneable接口深入理解深拷贝与浅拷贝

我们之前学过数组中的克隆方法，就是把一个数组中的内容全部拷贝到另外一个数组中去。

　　今天我们学的cloneable接口可以将一个对象的属性拷贝到另外一个对象里面去。

怎么使用cloneable接口

我们创建一个人这个类，人这个类中有两个属性，一个是分数，一个是smartphone这个对象(引用类型)。

class SmartPhone{ public int money = 9999;}class Person{ public int score = 96; SmartPhone smartPhone = new SmartPhone();}public class TestDemo { public static void main(String[] args){ Person person1 = new Person(); }}

我们现在要将这个person这个类实现cloneable接口，利用implements连接，同样的我们要重写这个cloneable这个接口中的方法。

　　这里我们要注意·重写cloneable这个方法，它的返回类型是object，object是Java中所有类的父类。

　　好，完成了接口的操作，我们接下来完成克隆的工作，我们怎么使用clone这个方法来进行克隆呢？？？

浅拷贝：

//浅拷贝class SmartPhone{ public int money = 9999;}class Person implements Cloneable{ public int score = 96; SmartPhone smartPhone = new SmartPhone(); @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } @Override public String toString() { return "Person{" + "score=" + score + ", smartPhone=" + smartPhone + }; }}public class TestDemo { public static void main(String[] args) throws CloneNotSupportedException { Person person1 = new Person(); Person person2 = (Person)person1.clone(); System.out.println(person1.smartPhone.money); System.out.println(person2.smartPhone.money); person1.smartPhone.money=9; System.out.println("===============拷贝之后================="); System.out.println(person1.smartPhone.money); System.out.println(person2.smartPhone.money); }}

　　原因是什么呢？？画一下图理解一下

　　这就是浅拷贝，对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此

　　为浅拷贝。只要将money值进行修改两个对象的money的值都改变，没有彻底的拷贝。

深拷贝

//深拷贝class SmartPhone implements Cloneable{ public int money = 9999; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } @Override public String toString() { return "SmartPhone{" + "money=" + money + }; }}class Person implements Cloneable{ public int score = 96; SmartPhone smartPhone = new SmartPhone(); @Override protected Object clone() throws CloneNotSupportedException { Person tmp = (Person)super.clone(); tmp.smartPhone= (SmartPhone) this.smartPhone.clone(); return tmp; } @Override public String toString() { return "Person{" + "score=" + score + ", smartPhone=" + smartPhone + }; }}public class TestDemo { public static void main(String[] args) throws CloneNotSupportedException { Person person1 = new Person(); Person person2 = (Person)person1.clone(); System.out.println(person1.smartPhone.money); System.out.println(person2.smartPhone.money); person1.smartPhone.money=9; System.out.println("===============拷贝之后================="); System.out.println(person1.smartPhone.money); System.out.println(person2.smartPhone.money); }}

　　此时为深拷贝，进行了彻底的拷贝。对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

　　到此这篇关于Java超详细分析抽象类和接口的使用的文章就介绍到这了,更多相关Java抽象类与接口内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。