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 关键字调用父类的构造方法