JAVA笔记:shape类（接口，继承，lambda表达式...)

写一段程序，实现shape面积，并可以对面积大小排序

定义父类shape类，并定义方法Area（）

定义第一个子类Circle类

定义第二个子类Rect类

定义接口Comparator,并写入compare（）方法

定义接口ISorter,继承Comparator类，并写入sorter()方法

定义AreaComparator类，实现Comparator接口

定义BubbleSorter类继承AreaComparator类，实现ISorter,Comparator接口

定义SelectSorter类继承AreaComparator类，实现ISorter,Comparator接口

定义Main类，写入主函数

关于这三种方法

一.定义一个AreaComparator的对象

二.不用定义对象，用lambda表达式（更加简洁，但是比较适合较为简单的关系）

三.不用定义对象，直接用匿名内部类

笔记：

关于接口（impelements，Interface）

关于继承（extends）

使用super调用父类中重写的方法、访问父类中被隐藏的字段

写一段程序，实现shape面积，并可以对面积大小排序

定义父类shape类，并定义方法Area（）

public class Shape {public  double Area() {return 0;}
}

定义第一个子类Circle类

包括圆心的坐标 x,y 圆的半径 r，构造函数及重写父类的Area（）方法

public class Circle extends Shape {public int x;public int y;public int r;Circle(int xx,int yy,int rr){this.x=xx;this.y=yy;this.r=rr;}public double Area() {      return r*r*3.14;        }}

定义第二个子类Rect类

包括矩形的长、宽 x,y，构造函数及重写父类的Area（）方法

public class Rect extends Shape{public int x;public int y;Rect(int xx,int yy){this.x=xx;this.y=yy;}public double Area() {      return x*y;     }}

定义接口Comparator,并写入compare（）方法

用来比较面积

public interface Comparator {public boolean compare(Shape s1,Shape s2);
}

定义接口ISorter,继承Comparator类，并写入sorter()方法

用来排序

public interface ISorter extends Comparator{public void sorter(Shape[] ss,Comparator c);
}

定义AreaComparator类，实现Comparator接口

public class AreaComparator implements Comparator{public boolean compare(Shape s1,Shape s2) {return (s1.Area()>s1.Area()) ? true :false;}
}

定义BubbleSorter类继承AreaComparator类，实现ISorter,Comparator接口

这是冒泡排序的排序方法

public class BubbleSorter extends AreaComparator implements ISorter,Comparator{public void sorter(Shape[] ss,Comparator c) {for(int i=0;i<ss.length-1;i++) {for(int j=0;j<ss.length-1-i;j++) {if(c.compare(ss[i], ss[j])) {Shape a=ss[j];ss[j]=ss[i];ss[i]=a;}}}}}

定义SelectSorter类继承AreaComparator类，实现ISorter,Comparator接口

这是选择排序的排序方法

public class SelectSorter extends AreaComparator implements ISorter,Comparator {public void sorter(Shape[] ss,Comparator c) {for(int i=0;i<ss.length;i++) {int minindex=i;for(int j=i+1;j<ss.length;j++) {if(c.compare(ss[minindex], ss[j])) {minindex=j;}Shape a=ss[minindex] ;ss[minindex]=ss[j];ss[j]=a;}}
}}

定义Main类，写入主函数

其中AreaComparator方法可以用对象，lambda表达式，匿名内部类实现

public class Main {public static void main(String[] args) {Shape[] sss=new Shape[6];for(int i=0;i<sss.length;i++) {sss[i]=new Rect(i,i);}ISorter sort=new BubbleSorter();       //普通写法Comparator c= new AreaComparator();    //普通写法sort.sorter(sss, c);                   //普通写法System.out.println("==========普通写法=========");for(int i=0;i<sss.length;i++) {System.out.println(sss[i].Area());}Shape[] shape=new Shape[6];for(int i=0;i<shape.length;i++) {shape[i]=new Rect(i,i);}sort.sorter(shape, new Comparator() {                 //匿名内部类public boolean compare(Shape s1,Shape s2) {        //匿名内部类return (s1.Area()>s1.Area()) ? true :false;    //匿名内部类}                                                  //匿名内部类});System.out.println("==========匿名内部类=========");for(int i=0;i<shape.length;i++) {System.out.println(shape[i].Area());}System.out.println("==========Lambda表达式=========");Shape[] ss=new Shape[6];for(int i=0;i<ss.length;i++) {ss[i]=new Circle(i,i,i);}sort.sorter(ss, (s1,s2)->(s1.Area()>s2.Area()));     //Lambda表达式for(int i=0;i<ss.length;i++) {System.out.println(ss[i].Area());}}
}

工作区图片

关于这三种方法

一.定义一个AreaComparator的对象

Comparator c= new AreaComparator();

将对象传入

sort.sorter(sss, c);

二.不用定义对象，用lambda表达式（更加简洁，但是比较适合较为简单的关系）

sort.sorter(ss, (s1,s2)->(s1.Area()>s2.Area()));

三.不用定义对象，直接用匿名内部类

sort.sorter(shape, new Comparator() {
           public boolean compare(Shape s1,Shape s2) {
               return (s1.Area()>s1.Area()) ? true :false;
           }
       });

笔记：

关于接口（impelements，Interface）

接口时为了弥补JAVA单继承的缺陷
在实现接口的时候，必须实现接口内的所有方法
抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法
接口是百分之百的抽象类
我们不能直接去实例化一个接口，因为接口中的方法都是抽象的，是没有方法体的
我们可以使用接口类型的引用指向一个实现了该接口的对象，并且可以调用这个接口中的方法(如：Comparator c=new AreaComparator）
用接口可以降低耦合性

关于继承（extends）

每个类都只能继承一个父类
每一个类都继承super（）类（超级父类）
在子类中被重写的方法，其访问权限允许大于但不允许小于被其重写的方法，比如在父类中是protected，在子类中可以是public，但不可以是private
子类继承其父类的所有public和protected成员，但不能继承其父类的private成员
当调用被重写的方法时，调用的版本是子类的方法；
当调用被隐藏的方法时，调用的版本取决于是从父类中调用还是从子类中调用。
使用super调用父类中重写的方法、访问父类中被隐藏的字段
对父类的构造放的调用必须放在子类构造方法的第一行
如果父类构造器没有参数，则在子类的构造方法中不需要使用 super 关键字调用父类构造方法
如果父类的构造方法带有参数，则必须在子类的构造方法中显式地通过 super 关键字调用父类的构造方法