java中的抽象类

1.什么是抽象类？

类--用来描述具有共同性质的一组事物的自定义复合数据类型
类--class关键字创建
        public class Hello{} --- 类
抽象类--通过abstract 修饰的java类就是。
        public abstract class Hello{}---抽象类

2.为什么要有抽象类？

例如:坐车收费，出租车有收费功能【1元/公里】，公交车有收费功能【全程1元】。
        出租车/公交车----汽车---收费功能
        出租车 extends 汽车 ---重写收费功能---【1元/公里】
        公交车 extends 汽车 ---重写收费功能--- 【全程1元】
        我们可以理解为汽车就是一个抽象类，出租车/公交车都是汽车的子类，出租车/公交车就会从汽车中继承来收费功能然后在根据自身的实际情况，重写收费功能就可以得到属于自己的收费功能实现。
    抽象类的子类往往都是同一种类型。
    抽象类实际上就是提供同一种类型事物的公共内容，由抽象类的子类根据自身的实际情况，来实现这个抽象类提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就好。

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

    类--实例变量，静态成员变量，构造方法，实例方法，静态方法
    抽象类--实例变量，静态成员变量，构造方法，实例方法，静态方法，【抽象方法】
    误区？判断一个类是不是抽象类不看有没有抽象方法。
    方法基本格式:修饰符  返回值  名称([参数]){方法体}
    实例方法:修饰符  返回值  名称([参数]){方法体}
    静态方法:修饰符 static  返回值  名称([参数]){方法体}
    构造方法：修饰符    类名([参数]){方法体}
    抽象方法：修饰符 abstract 返回值  名称([参数])
    抽象方法--使用abstract修饰的没有方法体的方法

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类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。

package com.wangxing.test3;
//抽象类
public abstract  class TestClass {
	//抽象方法
	public abstract void  info();
}
 
package com.wangxing.test3;
//子类
public class TestSunClass extends TestClass{
	@Override
	public void info() {
		System.out.println("TestSunClass子类重写父类TestClass的抽象方法");
	}
}
 
package com.wangxing.test3;
public class Person {
	//当某一个普通的java类中的方法参数是抽象类类型
	public  void  testPerson(TestClass  tc){
		System.out.println("Person类的实例方法");
		tc.info();
	}
}
 
Person per1=new Person();
//TestClass  tc1=new TestSunClass(); //上转型对象
//per1.testPerson(tc1);
TestSunClass tsc=new TestSunClass();//子类对象
per1.testPerson(tsc);

java中的接口

1.什么是接口？

通过interface关键字修饰的java元素就是接口。
格式:public  interface  接口名{}
         interface  接口名{}

2.为什么要有接口？

    为了克服java的单继承，接口可以被实现多个
    例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】
    出租车与飞机不是同一类事物，但是有相同的功能
    接口实际上就是提供不同类型事物的公共内容，由接口的子类根据自身的实际情况，来实现这个接口提供的公共内容。这样子类就不需要创建这个公共内容，只需要继承来重写一下就好。

3.接口如何实现？

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

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

    接口中可以有常量、静态方法、抽象方法。
    1、接口中变量一定是 public static  final修饰的常量。
    2、接口中的静态方法一定是public修饰的，public可以被省略。
    3、接口中的抽象方法一定是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.类可以通过implements关键字去实现一个/多个接口
    3.普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类.
    4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
    5.接口可以继承接口，并且可以继承父接口中的所有元素.
    6.利用接口回调对象创建出接口对象
    7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。

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

    接口回调对象与上转型对象很相似
    接口回调对象--接口的子类对象赋值给接口变量
    1.接口回调对象只能访问接口的抽象方法，实际上访问子类重写以后的抽象方法
    2.接口回调对象不能访问子类本身的方法，如果要访问就需要强制类型转换

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();

7.抽象类与接口的区别?