多态和接口

目录

1.接口

1.1接口的特征

2.接口应用 

3.接口在JDK1.8中的特性 

3.1在接口中定义静态方法

3.2在接口中定义默认方法实现

4.使用接口的好处：

5.接口和抽象类的区别：

6.父子类之间的转换

6.1子类转换成父类

6.2父类转换成子类

7.多态

 7.1抽象类（普通类）继承多态

 7.2接口实现多态

8.包(aaa.bbb.ccc)文件夹

8.1包的定义

8.2类的引入

9.API的使用

​编辑 9.1Math类

10.Scanner扫描器

---

1.接口

什么是接口：当一个抽象类，如果抽象类中的所有方法都是抽象的，那么我们就可以把它定义为一个接口，接口是对行为的抽象。类是对属性和行为的抽象。

语法

interface 接口名{

        方法定的定义；

        ….

}

1.1接口的特征

1.接口中的方法的定义不需要Abstract来修饰，默认就是抽象的

2.接口是不可以实例化的，需要有类来实现接口实现接口的语法：

class 类名       implements 接口名，接口名,…{

                 //实现每一个接口中的方法

        }

3.接口中的方法不能和private，static和final共存

4.在接口中可以定义”属性”，可以通过接口的实现类的实例来访问（不推荐），推荐使用接口名.常量，这是一个常量默认是public, static ,final

注意：常量的定义命名的规范要使用大写，单词之间要用“_”分隔。

5.接口可以继承接口(多继承)

interface A{
	
	public void methoda();
	
	public void method();
	
}

interface B {
	public void methodb();
	
	public void method();
}

//接口中可以多继承
interface C extends A,B{
	
	
	
}

class CImpl implements C{
	
	
	public void methoda(){
		
	}
	public void methodb(){
		
	}
	
	public void method(){
		
	}
}

public class TestPerson2{
	
	public static void main(String[] args){
	
	}
}

2.接口应用 

范例：使用接口方式计算圆和正方形的面积和周长。

     四个  两个     抽象：求面积  求周长

interface Cal{

        public double getLong();

        public double getArea();

}

正方形

class Rect implements Cal{

        //边长

        double r;

        public double getLong(){}

        public double getArea(){}

}

圆

class Circle implements Cal{

        //半径

        double r;

        public double getLong(){}

        public double getArea(){}

}

代码实现

interface Cal{
	
	/**
	 定义圆周率
	*/
	public static final double PI = 3.14;
	/**
	 求周长
	*/
	public double getLong();
	/**
	 求面积
	*/
	public double getArea();
	
}

class Rect implements Cal{
	//边长
	double r;
	
	public Rect(double r){
		this.r = r;
	}
	
	public double getLong(){
		return 4*r;	
	}
	public double getArea(){
		return r*r;	
	}

}

class Circle implements Cal{
	//半径
	double r;
	
	public Circle(double r){
		this.r = r;
	}
	
	public double getLong(){
		return 2*Cal.PI *r;
	}
	public double getArea(){
		return Cal.PI * r *r;
	}
}

public class TestCal{
	
	public static void main(String[] args){
		
		//创建一个正方形
		Rect rect = new Rect(10.0);
		double rectLong = rect.getLong();
		double rectArea = rect.getArea();
		
		System.out.println("正方形的周长是："+rectLong);
		System.out.println("正方形的面积是："+rectArea);
		
		Circle c = new Circle(10.0);
		double cLong = c.getLong();
		double cArea = c.getArea();
		
		System.out.println("圆的周长是："+cLong);
		System.out.println("圆的面积是："+cArea);
	
	}
}

3.接口在JDK1.8中的特性 

3.1在接口中定义静态方法

interface ArrayUtils{
	
	public static void printArr(int[] arr){
		for(int i = 0; i < arr.length; i++)
			System.out.print(arr[i]+"\t");
	}
}

public class TestPerson4{
	
	public static void main(String[] args){
		ArrayUtils.printArr(new int[]{1,2,4,6,7});
	}
}

3.2在接口中定义默认方法实现

interface Person{
	
	public default  void learn(){
		System.out.println("我是一个默认实现的方法");
	}
}

class Student implements Person{
	
	public void learn(){
		System.out.println("学生在学习国学");
	}
}

public class TestPerson5{
	
	public static void main(String[] args){
		Student s = new Student();
		s.learn();
		
	}
}

4.使用接口的好处：

1. 接口定义的是一种标准，可以使我们的代码分层开发，分模块开发。

2. 降低代码的耦合度，提高代码的可扩展性和可维护性

3. 接口改进了单继承的局限。  

5.接口和抽象类的区别：

1.接口是行为的抽象可以有静态方法，抽象方法和默认方法，抽象类中可以有所有方法。

2.接口和抽象类都不能实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承然后实例化子类。

3.抽象类只能单继承，接口可以多继承接口（jdk1.7），接口还可以多实现。

4.接口中的“属性”是public static final类型的，抽象类中的属性跟普通类中的属性没有区别。

5.接口中的方法默认就是抽象的不需要加absract，抽象类中的抽象方法需要加abstract关键字。

6.父子类之间的转换

6.1子类转换成父类

子类可以自动转型成父类

1.如果子类对父类的方法有覆写，并且子类的实例赋值给父类的引用，通过这个引用来调用这个覆写的方法的时候，调用的是子类。

2.父类指向子类的实例的引用不能调用子类的特有的方法和属性。

3.如果父子类有同名的属性，那么父类指向子类的实例的引用调用这个属性的时候调用的还是父类的，不要和方法混淆。

class Teacher{
	String name = "亮哥";
	
	int age;
	
	public void teach(){
		System.out.println(name+"在教课");
	}
}

class JavaTeacher extends Teacher{
	
	boolean isGlass;
	
	String name = "大亮哥";
	
	public void teach(){
		System.out.println(name+"在教java课");
	}
	
	public void playBall(){
		System.out.println(name+"在打篮球");
	}
	
}

public class TestTeacher{
	
	public static void main(String[] args){
		
		//子类自动转换成父类
		Teacher jt = new JavaTeacher();
		jt.name = "亮哥";
		jt.teach();
		//父类的引用不能调用子类的特有方法
		/*
		jt.playBall();
		jt.isGlass = true;
		*/
		System.out.println(jt.name);
	}
}

6.2父类转换成子类

（该父类要转换的子类一定是它的子类真身）

特点：

        1.父类转换成子类不能自动完成。

        2.父类转换成子类的前提是父类的真身是这个子类，转回子类后，就可以访问子类内部的方法和属性。

        3.如果这个父类的真身是子类B，不能强制转换成子类A，只能转换成B。

        4.抽象类作为父类同样符合上述理论

        5.接口中也是完全符合上述理论，但是注意接口中没有属性。

class Teacher{
	String name;
	
	int age;
	
	public void teach(){
		System.out.println(name+"在教课");
	}
}

class JavaTeacher extends Teacher{
	//子类属性
	boolean isGlass;
	
	//重写
	public void teach(){
		System.out.println(name+"在教java课");
	}
	//子类方法
	public void playBall(){
		System.out.println(name+"在打篮球");
	}
	
}


class PHPTeacher extends Teacher{
	
    //重写
	public void teach(){
		System.out.println(name+"在教PHP课");
	}

}

public class TestTeacher2{
	
	public static void main(String[] args){
		
		Teacher t = new JavaTeacher();
		//不能转
		JavaTeacher jt = (JavaTeacher)t
	}
}

7.多态

多态就是行为具有表现多种功能的能力。

 7.1抽象类（普通类）继承多态

通过继承的方式来体现的多态。

abstract class Teacher{
	String name;
	
	int age;
	
	public abstract void teach();
}

class JavaTeacher extends Teacher{
	

	public void teach(){
		System.out.println(name+"在教java课");
	}
	
}

class PHPTeacher extends Teacher{
	

	public void teach(){
		System.out.println(name+"在教PHP课");
	}
	
}

public class TestTeacher5{
	
	public static void main(String[] args){
		//创建一个java老师
		Teacher t = new JavaTeacher();
		t.name = "亮哥";
		t.teach();
		
		
		t = new PHPTeacher();
		t.name = "龙哥";
		t.teach();
	}
}

领导考核讲师的使用多态来完成。

abstract class Teacher{
	String name;
	
	int age;
	
	public abstract void teach();
}

class JavaTeacher extends Teacher{
	
	public void teach(){
		System.out.println(name+"在教java课");
	}
	
}

class PHPTeacher extends Teacher{
	
	public void teach(){
		System.out.println(name+"在教PHP课");
	}
	
}

//考核老师
class Leader{
	/**
	 	考核java老师
	 	
	 	Teacher t = new PHPTeacher();
	*/
	public void check(Teacher t){
		System.out.println("开始讲课");
		t.teach();
		System.out.println("打分");
	}
	
}

public class TestTeacher7{
	
	public static void main(String[] args){
		//创建一个java老师
		JavaTeacher jt = new JavaTeacher();
		jt.name = "亮哥";
			
		PHPTeacher pt = new PHPTeacher();
		pt.name = "龙哥";
		
		//创建一个领导对象
		Leader leader = new Leader();
		leader.check(jt);
		System.out.println("---------------------");
		leader.check(pt);
		
	}
}

注意：t instanceof JavaTeacher判断父类的实际的真身是哪个子类的实例

public void check(Teacher t){
		if(t instanceof JavaTeacher){
			System.out.println("java老师开始讲课");
		}
		if(t instanceof PHPTeacher){
			System.out.println("PHP老师开始讲课");
		}
		t.teach();
		System.out.println("打分");
	}

继承多态，不仅仅是父类是抽象类，父类是普通类也是可以的。

多态的条件：

        1.子类对父类有方法重写

        2.父类的引用指向子类的实例，调用覆写的这个方法的时候，调用是子类的方法。

 7.2接口实现多态

interface Teacher{
	public  void teach();
}

class JavaTeacher implements Teacher{
	
	String name;
	
	int age;
	
	public void teach(){
		System.out.println(name+"在教java课");
	}
	
}

class PHPTeacher implements Teacher{
	
	String name;
	
	int age;
	
	public void teach(){
		System.out.println(name+"在教PHP课");
	}
	
}
class Leader{
	/**
	 	考核java老师
	 	
	 	Teacher t = new PHPTeacher();
	*/
	public void check(Teacher t){
		if(t instanceof JavaTeacher){
			System.out.println("java老师开始讲课");
		}
		if(t instanceof PHPTeacher){
			System.out.println("PHP老师开始讲课");
		}
		t.teach();
		System.out.println("打分");
	}
	
}

public class TestTeacher10{
	
	public static void main(String[] args){
		//创建一个java老师
		JavaTeacher jt = new JavaTeacher();
		jt.name = "亮哥";
			
		PHPTeacher pt = new PHPTeacher();
		pt.name = "龙哥";
		
		//创建一个领导对象
		Leader leader = new Leader();
		leader.check(jt);
		System.out.println("---------------------");
		leader.check(pt);
		
	}
}

8.包(aaa.bbb.ccc)文件夹

8.1包的定义

包：就是文件夹

作用：对类做分类管理，可以区分同名不同包的类。

语法: package 包名（不同级别用“.”来分隔）;，如 package com.rl;, 位置放置文件的有效代码第一行（注释不算）， 包的名字一定是英文的小写。

如何编译：

Javac –d . 源文件

8.2类的引入

 1.如果两个类在相同的包内，可以不用引入类就能直接用

2.如果两个类在不同的包内，必须要引入类才能使用。前提被引入的类是public的

        引入类的语法 在包的下行类的定义的上行

        import 包名.类名;

9.API的使用

我们学习java编程面对2中类

        1.我们自己写的类。

        2.用其他人写好的类来使用。

API是把jdk里面提供好的类梳理成了一个文档，方便我们来查阅。

src.zip是jdk的源码

基本信息

类的属性的摘要 

 类的构造器的摘要

方法的摘要

从父类继承下来的方法。 

 9.1Math类

java中java.lang下面的所有类都不需要引入，可以直接来使用。

public class Demo{
	
	/*
	  自然对数：Math.E
		圆周率：Math.PI
		绝对值：Math.abs(-1.5)
		把小数去掉整数加1      Math.ceil(12.1)
		把小数位舍弃      Math.floor(12.9)
		比较两个数的大小    Math.max(12.9, 27)
		比较两个数的大小    Math.min(12.9, 27)
		计算某个数的n次幂  Math.pow(3, 3)
		四舍五入    Math.round(4.5)
		开平方        Math.sqrt(16));
	
	*/
	public static void main(String[] args){
		System.out.println(Math.E);
		System.out.println(Math.PI);
		
		int r1 = Math.abs(-1);
		System.out.println("绝对值是："+r1);
		//取整
		double r2 = Math.ceil(1.8);
		System.out.println("ceil向上取整："+r2);
		
		double r3 = Math.floor(1.8);
		System.out.println("ceil向下取整："+r3);
		
		int r4 = Math.max(2,5);
		System.out.println("求最大值："+r4);
		
		int r5 = Math.min(2,5);
		System.out.println("求最小值："+r5);
		
		double r6 = Math.pow(3, 3);
		System.out.println("3的3次幂"+r6);
		
		long r7 = Math.round(1.6);
		System.out.println("四舍五入："+r7);
		
		double r8 = Math.sqrt(16);
		System.out.println("开平方："+r8);
	}
}

10.Scanner扫描器

扫描器就是让我们运行程序的时候可以从控制台来输入数据。

Scanner的使用必须要引入这个类

我们使用的构造器

常用的方法

 下面这行代码运行到这里，程序会阻塞等待我们输入一个int的值，回车后程序会继续向下走score就赋值了。

import java.util.Scanner;

public class Demo1{
	
	public static void main(String[] args){
		
		//创建一个Scanner
		Scanner s = new Scanner(System.in);
		//从控制台来扫描一个int的数值
		int score = s.nextInt();
		
		if(score >= 90){
			System.out.println("不错哟，A级");
		}
		
		if(score < 90 && score >= 60){
			System.out.println("一般哟，B级");
		}
		
		if(score < 60){
			System.out.println("继续加油，C级");
		}
		
	}
}

获得输入的一行数据。

import java.util.Scanner;

public class Demo2{
	
	public static void main(String[] args){
		
		//创建一个Scanner
		Scanner s = new Scanner(System.in);
		//从控制台来扫描一行以字符串方式返回
		String line = s.nextLine();
		System.out.println("您输入的数据是："+line);
		
	}
}