抽象类和接口

5.12.什么是上转型对象及其基本特征？

上转型对象—子类对象赋值给父类变量。
例如：

package com.wangxing.test1;
//父类
public class Person {	
	public  void  testPerson() {		
		System.out.println("父类Person的实例方法");	
	}
}

package com.wangxing.test1;
//子类
public class Student extends Person{	
	public  void  testStudent() {		
		System.out.println("子类Student的实例方法");	
	}
}
package com.wangxing.test1;
public class Test1 {	
	public static void main(String[] args) {		
		//上转型对象---子类对象赋值给父类变量。		
		//person上转型对象表示将子类对象向上转型成父类对象		
		Person  person=new Student(); //person上转型对象		
		//上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
		person.testPerson();		
		//person.testStudent();		
		//上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。		
		Student stu=(Student)person;		
		stu.testStudent();	
	}
}

上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的
变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。

5.13.什么是抽象类？

类–用来描述具有共同性质的一组事物的自定义复合数据类型
通过class关键字创建一个java类。
通过abstract 修饰的java类就是抽象类。
格式: 访问修饰符 abstract class 类名{}
例如：

public  abstract  class Hello{ }

5.14.为什么要使用抽象类？

抽象类的出现体现出java的重构.[重复的动作提取出来]
抽象类是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
例如:坐车收费，出租车有收费功能【1元/公里】，公交车有收费功能【全程1元】
抽象类的子类往往都是同一种事物。

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

抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
抽象方法–abstract修饰，没有方法体的方法。
抽象方法就是抽象类提供给子类的一般形式。
抽象类中可以有抽象方法，也可以一个抽象方法都没有。普通的java类中是不能有抽象方法的。
例如:

package com.wangxing.test1;
public abstract  class MyAbstractClass {
	public  int  id=1001; //实例变量	
	public static String  name="zhangsan"; //类变量	
	public MyAbstractClass() {		
		System.out.println("构造方法");	
	}
	public  void  testMethod() {		
		System.out.println("实例方法");	
	}	
	public static void  staticMethod() {		
		System.out.println("类方法");	
	}	
	//abstract修饰，没有方法体的方法就是抽象方法	
	//抽象方法就是抽象类提供给子类的一般形式	
	//抽象类中可以有抽象方法，也可以一个抽象方法都没有	
	public abstract  void  abstractMethod();
}

5.16.抽象类的具体用法

1.抽象类不能new
2.普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
3.抽象类可以继承其他的抽象类，可以不用重写抽象方法。
4.利用上转型对象创建出抽象类对象
5.抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
6.抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。
7.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。
例如：

package com.wangxing.test1; 

public abstract  class MyAbstractClass {
	public  int  id=1001; //实例变量	
	public static String  name="zhangsan"; //类变量		
	public MyAbstractClass() {		
		System.out.println("构造方法");	
	}
	
	public  void  testMethod() {		
		System.out.println("实例方法");	
	}
	
	public static void  staticMethod() {		
		System.out.println("类方法");	
	}	
	//abstract修饰，没有方法体的方法就是抽象方法	
	//抽象方法就是抽象类提供给子类的一般形式	
	//抽象类中可以有抽象方法，也可以一个抽象方法都没有	
	public abstract  void  abstractMethod();	
}

package com.wangxing.test1;
//普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
public  class SunClass extends MyAbstractClass{	
	//子类重写抽象类的抽象方法
	//去掉abstract，加上方法体	
	public void abstractMethod() {		
		System.out.println("子类重写抽象类的抽象方法");			
	}
}

package com.wangxing.test1; 
public class MyClass { 	
	public  void  testMyClass(MyAbstractClass  mac) {
	}
}

package com.wangxing.test1; 
public class Test1 { 	
	public static void main(String[] args) {
		//抽象类的具体用法		
		//1.抽象类不能new		
		//MyAbstractClass mac=new MyAbstractClass();		
		//2.利用上转型对象创建出抽象类对象		
		MyAbstractClass mac=new SunClass();		
		System.out.println("id=="+mac.id);		
		System.out.println("name=="+MyAbstractClass.name);		
		System.out.println("name=="+mac.name);		
		mac.testMethod();		
		mac.staticMethod();		
		//子类重写以后的抽象方发		
		mac.abstractMethod();
		MyClass  mc=new MyClass();		
		//当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象		
		mc.testMyClass(mac);		
		//抽象类的子类对象		
		SunClass  sun=new SunClass();		
		mc.testMyClass(sun);	
	}
}

5.17.什么是接口？

通过interface关键字修饰的java元素就是接口。

package com.wangxing.test1;
//接口
public interface MyInterface { 

}

5.18.为什么要使用接口？

接口的出现体现出java的扩展.[为了以后程序扩展方便]
接口是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】
接口的子类往往都是不同种类事物。
接口主要是提供功能，提供功能不去实现该功能，由不同的不同种类事物去实现。
为了克服java的单继承问题，可以使用接口，可以被使用多个。

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

接口中可以有类变量、类方法、抽象方法。
1 . 接口中变量一定是 public static修饰的类变量。
2 . 接口中的类方法一定是public修饰的，public可以被省略
3 . 接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
例如：

package com.wangxing.test1;
//接口
public interface MyInterface {
	//接口中的变量一定是 public static修饰的类变量	
	// public static是可以省略	
	public  int  id=1001; //类变量	
	int age=23;	
	public static String  name="lisi"; //类变量	
	//接口中没有构造方法	
	//public  MyInterface() {}	
	//接口中没有实例方法	
	//public  void  testMethod() {}	
	//接口中的类方法一定是public修饰的，public可以被省略	
	public static void  staticMethod() {}	
	//接口中的抽象方法一定是public  abstract修饰的	
	//public  abstract可以省略	
	public  abstract void abstractMethod1();	
	abstract void abstractMethod2();	
	void abstractMethod3();
}

5.20.接口的具体用法

1.接口不能new
2.类可以通过implements关键字去实现一个/多个接口
实现一个public class MyClass implements MyInterface{}
实现多个接口 public class MyClass implements MyInterface1,MyInterface2,…,MyInterface_n{}
3.普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类.
4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
5.接口可以继承接口，并且可以继承父接口中的所有元素.
package com.wangxing.test1;
//接口可以继承接口，并且可以继承父接口中的所有元素
public interface DemoInterface extends MyInterface{

}
6.利用接口回调对象创建出接口对象
7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。
例如:

package com.wangxing.test1;
//接口
public interface MyInterface {
	//接口中的变量一定是 public static修饰的类变量	
	// public static是可以省略	
	public  int  id=1001; //类变量	
	int age=23;	
	public static String  name="lisi"; //类变量	
	//接口中没有构造方法	
	//public  MyInterface() {}	
	//接口中没有实例方法	
	//public  void  testMethod() {}	
	//接口中的类方法一定是public修饰的，public可以被省略	
	public static void  staticMethod() {		
		System.out.println("接口中的类方法");	
	}	
	//接口中的抽象方法一定是public  abstract修饰的	
	//public  abstract可以省略	
	public  abstract void abstractMethod1();	
	abstract void abstractMethod2();	
	void abstractMethod3();
}

package com.wangxing.test1;
//类可以通过implements关键字去实现一个/多个接口
//普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类
public class MyClass implements MyInterface{
	@Override	
	public void abstractMethod1() {		
		System.out.println("子类重写抽象类的抽象方法");	
	}	
	@Override	
	public void abstractMethod2() {		
		// TODO Auto-generated method stub			
	}	
	@Override	
	public void abstractMethod3() {		
		// TODO Auto-generated method stub			
	}
}

package com.wangxing.test1; 
public class DoClass {   
	public  void  test(MyInterface inter) {	      
	}
}

package com.wangxing.test1;
public class Test1 {
	public static void main(String[] args) {		
		//1.接口不能new		
		//new MyInterface();		
		MyInterface inter1=new MyClass();		
		System.out.println(inter1.name);		
		MyInterface.staticMethod();		
		inter1.abstractMethod1();
						
		DoClass  dc=new DoClass();		
		dc.test(inter1);		
		MyClass  mc=new MyClass();		
		dc.test(mc);	
	}
}

5.21.抽象类与接口的区别

抽象类	接口
abstract class	interface
extends 一个	implments 一个/多个
抽象类的子类往往都是同一种事物	接口的子类往往都是不同种类事物
抽象类的出现体现出java的重构	接口的出现体现出java的扩展
抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】	接口中可以有类变量、类方法、抽象方法
没有方法体的方法	一定是 public static修饰的类变量
传递上转型对象	传递接口回调对象

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

接口回调对象与上转型对象很相似
上转型对象–子类对象赋值给父类变量。
接口回调对象—实现了该接口的子类对象赋值给接口变量。
接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法，
如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
例如：

package com.wangxing.test1;
public interface TestInterface {	
	void testMethod();
}

package com.wangxing.test1;
public class SunClass implements TestInterface{	
	public  void  sunMethod() {		
		System.out.println("SunClass类的实例方法");	
	}	
	@Override	
	public void testMethod() {		
		System.out.println("子类重写接口的抽象方法");	
		}
	}

package com.wangxing.test1;
public class Test1 {	
	public static void main(String[] args) {		
		//接口回调对象---实现了该接口的子类对象赋值给接口变量。		
		TestInterface  inter1=new SunClass();		
		//接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法		
		inter1.testMethod();		
		//inter1.sunMethod();		
		//如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象		
		SunClass sc=(SunClass)inter1;		
		sc.sunMethod();	
	}
}

5.23.static \ this \ super \ final 关键字的用法

static–静态的【提前分配内存】
--------修饰的变量就是静态成员变量【类变量】，可以用类名访问，也可以用对象访问
--------修饰的方法就是静态方法量【类方法】，可以用类名访问，也可以用对象访问
this—本类对象【出现在哪一个类中就表示哪一个类的对象】
-------本类中调用本类的实例变量\类变量\实例方法\类方法，可以省略
-------this是不能出现在静态方法中
super–子类中表示父类对象
---------子类中访问父类构造方法“super([参数])”。
---------子类中访问父类的实例方法/实例变量”super.实例变量/实例方法”。
final—最终的
---------final修饰的变量不能被重新赋值。
---------fianl修饰的静态成员变量叫静态常量。【静态常量全字母大写】
---------例如: public final static String TEXT=“java”;
---------final修饰的方法不能被重写。
---------final修饰的类不能被继承，没有子类。
例如:

package com.wangxing.test1;
//final修饰的类不能被继承，没有子类。
//public final class TestClass {
public class TestClass {
	public final String  name="zhangsan";   
	public final void info() {	   
		System.out.println("父类TestClass类的实例方法");   
	}
}

package com.wangxing.test1;
public class MyClass extends TestClass{		
	//final修饰的方法不能被重写	
	/*	
	public  void info() {		
		System.out.println("子类重写父类的方法");	
	}	
	*/
}

package com.wangxing.test1;
public class Test1 {	
	public static void main(String[] args) {		
		TestClass tc=new TestClass();		
		System.out.println("name=="+tc.name);		
		//final修饰的变量不能被重新赋值		
		//tc.name="lisi";		
		System.out.println("name=="+tc.name);		
		tc.info();		
		MyClass  mc=new MyClass();		
		mc.info();	
	}
}