十二、Java中的抽象类和接口【20220622】

1.什么是抽象类

    类---通过class关键字创建的java元素
    抽象类---通过abstract class创建的java元素
    判断一个java类是否是一个抽象类，看它是否使用abstract修饰

2.为什么要有抽象类

    为了减少代码的重复编写，提供代码的重用性。
    例如：坐车收费----公交车收费【全程1元】
                             ----出租车收费【每公里1元】
    公交车 extends 汽车[收费功能]
    出租车 extends 汽车[收费功能]
    汽车提供了收费功能，但是没有具体的收费标准，具体的收费标准是由公交车/出租车根据自身的实际情况决定收费标准。
    我们可以认为汽车是一个抽象类,它只提供功能,不给具体实现;
    公交车/出租车都是汽车这个抽象类的子类，公交车/出租车就会从汽车的抽象类上继承功能，根据自身的实际情况实现这个功能。
    抽象类为同一种类的事物提供功能，让它的子类根据自身的实际情况实现这个功能。

3.抽象类中可以有哪些元素

    类---实例变量,静态成员变量，构造方法，实例方法，静态方法
    抽象类---实例变量,静态成员变量，构造方法，实例方法，静态方法，抽象方法
    抽象方法---1.使用abstract关键字修饰
                      2.没有方法体“{}”

package com.wangxing.chouxiang1;
//抽象类--通过abstract class创建的java元素
public abstract class ChouXiangLei1 {
	//实例变量
	public  String  shili="实例变量";
	//静态成员变量
	public static String  staticbianliang="静态成员变量";
	//构造方法
	public ChouXiangLei1(){
		System.out.println("抽象类中的构造方法");
	}
	//实例方法
	public void  shiliMethod(){
		System.out.println("抽象类中的实例方法");
	}
	//静态方法
	public static void  staticMethod(){
		System.out.println("抽象类中的静态方法");
	}
	//抽象方法
	//1.使用abstract关键字修饰
	//2.2.没有方法体“{}”
	public abstract void  abstractMethod();
}

 4.抽象类的具体用法

     1.抽象类不能通过new+构造方法的形式创建对象的
     2.抽象类中可以有抽象方法，可以一个抽象方法都没有
     3.当一个普通的java类继承一个抽象类，就需要实现抽象类提供的所有抽象方法
        也可以将这个普通的java类改成抽象类
     4.抽象类可以继承抽象类
     5.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是            抽象类的子类对象。

5.卖水果实例 

package com.wangxing.test1;
//水果抽象类
public abstract class ShuiGuo {
	//抽象方法
	public abstract void  chi();
}

package com.wangxing.test1;
//水果--西瓜
public class XiGua extends ShuiGuo{
	@Override
	public void chi() {
		System.out.println("用刀切开吃西瓜");
	}
}

package com.wangxing.test1;
//水果--苹果
public class PingGuo extends ShuiGuo{
	@Override
	public void chi() {
		System.out.println("削皮以后吃苹果");
	}
}

package com.wangxing.test1;
public class ShuiGuoDian {
	public static ShuiGuo  maiShuiGuo(String name){
		ShuiGuo  sg=null;
		if(name.equals("西瓜")){
			sg=new XiGua();
		}
		if(name.equals("苹果")){
			sg=new PingGuo();
		}
		if(name.equals("桃子")){
			sg=new TaoZi();
		}
		return sg;
	}
}

package com.wangxing.test1;
public class TestMain {
	public  static  void  main(String args[]){
		ShuiGuo sg=ShuiGuoDian.maiShuiGuo("桃子");
		if(sg!=null){
			sg.chi();
		}else{
			System.out.println("没有买到想吃的水果");
		}
		
	}
}

 java中的接口

1.什么是接口

    接口---使用interface关键字创建的java元素
    例如：public interface  接口名称{}
               interface  接口名称{}

2.为什么要使用接口

    1.接口为不同种类的事物提供功能，让它的子类根据自身的实际情况实现这个功能。
       接口---[收费功能]
       坐车---实现接口--重写收费功能
       看电影---实现接口--重写收费功能
       坐车和看电影不是同一种类的事物
    2.一个java类只能继承一个父类【单继承】，接口可以实现多个，可以克服类的单继承带来的问
题。

3.接口如何实现

    通过implements关键字类实现一个或多个接口，如果有多个“，”分开。
    格式：public  class  类   implements   接口名1,接口名2...{}

4.接口中可以有哪些元素

   接口中的变量都是使用public static final修饰的静态常量，public static final可以省略。
   接口中的抽象方法都是使用public abstract修饰的抽象方法，public abstract可以省略。
   接口中可以有静态方法。

package com.wangxing.test1;
//接口--使用interface关键字创建的java元素
public interface MyInterface {
	//静态常量
	//接口中的变量都是使用public static final修饰的静态常量，
	//public static final可以省略
	public static final String  staticbianliang1="静态成员变量";
	public static String  staticbianliang2="静态成员变量";
	public String  staticbianliang3="静态成员变量";
	String  staticbianliang4="静态成员变量";
	//不能有构造方法
	//public  MyInterface(){}
	//不能有实例方法
	//public  void shiliMethod(){}
	//静态方法
    public static  void staticMethod(){
    	System.out.println("接口中的静态方法");
    }
    //抽象方法
    //接口中的抽象方法都是使用public abstract修饰的抽象方法，
    //public abstract可以省略
    public abstract void abstractMethod1();
    public  void abstractMethod2();
    void abstractMethod3();
}

 5.接口的具体用法

    1.接口不能通过new的形式创建对象的，可以通过这个接口的子类来创建接口对象
    2.接口中可以有抽象方法，可以一个抽象方法都没有
    3.当一个普通的java类实现接口，就需要实现接口提供的所有抽象方法，也可以将这个普通的           java类改成抽象类
    4.接口可以继承接口，而且是全部继承父接口中的所有元素。
    5.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接         口的子类对象。

6.什么是接口回调对象及其基本特征

    接口回调对象与上转型对象相似。
    上转型对象---子类对象赋值给父类变量
    接口回调对象---接口的子类对象赋值给接口变量

    基本特征：接口回调对象不能访问使用子类自己定义的变量和方法，只能访问接口提供的变量和方法，当访问接口中的抽象方法时，实际上访问的是被子类重写的抽象方法。

package com.wangxing.test1;
public interface MyInterface {
    //抽象方法
    //接口中的抽象方法都是使用public abstract修饰的抽象方法，
    //public abstract可以省略
    //public abstract void abstractMethod1();
    //public  void abstractMethod2();
    void abstractMethod3();
}

package com.wangxing.test1;

public  class SunClass implements MyInterface{
	@Override
	public void abstractMethod3() {
		System.out.println("实现重写接口的抽象方法");
	}
	public  void  test1(){
		System.out.println("SunClass子类自己的实例方法");
	}
}

//接口回调对象---接口的子类对象赋值给接口变量
MyInterface my1=new SunClass();
//接口回调对象不能访问使用子类自己定义的变量和方法，只能访问接口提供的变量和方法，
//当访问接口中的抽象方法时，实际上访问的是被子类重写的抽象方法
//my1.test1(); //错误
//如果需要接口回调对象访问子类自己定义的变量和方法，
//那么需要将接口回调对象强制类型转换成子类对象
SunClass sc1=(SunClass)my1;
sc1.test1();
//my1.abstractMethod3();