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

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类中是不能有抽象方法的。

5.16.抽象类的具体用法

     1.抽象类不能new

     2.普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。

     3.抽象类可以继承其他的抽象类，可以不用重写抽象方法。

     4.利用上转型对象创建出抽象类对象

     5.抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。

     6.抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。

      例如：

package com.wangxing.abstract2;
//抽象类中的元素 实例变量 类变量 构造方法 实例方法 类方法   抽象方法
public abstract class AbstractClass2 {
	public String shiliname="抽象类中的实例变量";
	public static String staticname="抽象类中的类变量";
	public AbstractClass2(){
		System.out.println("抽象类中的构造方法");
	}
	public void shiliMethod(){
		System.out.println("抽象类中的实例方法");
	}
	public static void staticMethod(){
		System.out.println("抽象类中的类方法");
	}
	//抽象方法
	//abstract修饰
	//没有方法体
	//能够被子类继承
	//抽象方法就是抽象类提供给子类的一般形式【方法】
	public abstract void abstractMethod();
	//注意：抽象类中可以有抽象方法，也可以没有
}

ackage com.wangxing.abstract2;
//普通的java类继承了抽象类，就要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类
public class SonAbstractClass2 extends AbstractClass2 {
	
	//重写抽象方法
	//去掉 abstract
	//给出方法体
	public void abstractMethod() {
		System.out.println("子类中重写父类抽象类的抽象方法");

	}
}

   主方法：

package com.wangxing.abstract2;

public class AbstractMain2 {

	public static void main(String[] args) {
		//抽象类不能new
		//利用上转型对象创造出抽象类对象
		//上转型对象
		AbstractClass2 a2=new SonAbstractClass2();
		//抽象类对象访问抽象类中的变量和方法
		System.out.println("name=="+a2.shiliname);
		System.out.println("staticname=="+a2.staticname);
		a2.shiliMethod();
		a2.staticMethod();
		//抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。
		a2.abstractMethod();
	}

}

     7.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。

package com.wangxing.abstract2;

public class PutongClass3 {
	public void TestPutongMethod3(AbstractClass3 abclass){
		System.out.println("普通java类的实例方法，参数是抽象类类型");
		//抽象类对象访问抽象方法是，实际上访问的是子类重写以后的抽象方法
		
	}

}

package com.wangxing.abstract2;

public abstract class AbstractClass3 {
	public abstract void abstractMethod3();

}

package com.wangxing.abstract2;

public class SonAbstractClass3 extends AbstractClass3{
	public void abstractMethod3(){
		System.out.println("子类重写父类的抽象方法");
	}

}

   主方法

package com.wangxing.abstract2;

public class AbstractMain3 {

	public static void main(String[] args) {
		PutongClass3 pt=new PutongClass3();
		//可以传递上转型对象
		SonAbstractClass3 abclass1=new SonAbstractClass3();
		pt.TestPutongMethod3(abclass1);
		//也可以传递抽象类的子类对象。
		SonAbstractClass3 sonclass=new SonAbstractClass3();
		pt.TestPutongMethod3(sonclass);
	}

}

5.17.什么是接口？

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

     public interface MyInterface {    }

5.18.为什么要使用接口？

     接口的出现体现出java的扩展.[为了以后程序扩展方便]

     接口是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。

     例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】

     接口的子类往往都是不同种类事物。

     接口主要是提供功能，提供功能不去实现该功能，由不同的不同种类事物去实现。

     为了克服java的单继承问题，可以使用接口，可以被使用多个。

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

     接口中可以有类变量、类方法、抽象方法。

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

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.利用接口回调对象创建出接口对象

    例如：

  

package com.wangxing.interfacedemo1;
//通过interface关键字修饰的java元素就是接口。
//为了克服java的单继承问题，可以使用接口，可以被使用多个。
//接口中可以有类变量、类方法、抽象方法。
//1.接口中变量一定是 public static修饰的类变量，因此 public static是可以省略的。
//2.接口中的类方法一定是public修饰的，public可以被省略
//3.接口中的抽象方法一定是public  abstract修饰的，public  abstract可以省略
public interface TestInterface2 {
		public static String staticname="接口中的类变量";
		public String name1="接口中省略static的类变量";
		String name2="接口中省略public static的类变量";
		/*
		接口中不能有构造方法
		public TestInterface2(){
			
		}
		*/
		/*接口中不能有实例方法
		public void shiliMethod(){
			
		}
		*/
		//2.接口中的类方法一定是public修饰的，public也可以被省略
		public static void staticMethod(){
			System.out.println("接口中的类方法");
		}
		//3.接口中的抽象方法一定是public  abstract修饰的，public  abstract也可以省略
		public abstract void abstractMethod1();
		void abstractMethod2();
		
				
}

package com.wangxing.interfacedemo1;

public class SonTestInterface2 implements TestInterface2{
		public  void abstractMethod1(){
			System.out.println("接口的子类重写接口中的抽象方法");
		}
		public  void abstractMethod2(){
			System.out.println("接口的子类重写接口中的抽象方法");
		}

}

     主方法：

package com.wangxing.interfacedemo1;

public class TestInterfaceMain2 {

	public static void main(String[] args) {
		//接口不能new
		//利用接口回调对象创建出接口对象
		TestInterface2  t2=new SonTestInterface2();
		System.out.println("staticname=="+t2.staticname);
		System.out.println("name1=="+t2.name1);
		System.out.println("name2=="+t2.name2);
		//接口中的类方法不能通过接口对象访问
		//t2.staticMethod();//错误
		//只能通过接口类名访问
		TestInterface2.staticMethod();
		//接口回调对象调用的抽象方法，实际上是被子类重写以后的方法
		t2.abstractMethod1();
		t2.abstractMethod2();
	}

}

     7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。

     例如：

package com.wangxing.interfacedemo1;

public class PuTongClass3 {
		public void TestPuTong(TestInterfaceClass3 inter3){
			System.out.println("普通java类中的实例方法,参数是接口型");
		}
}

package com.wangxing.interfacedemo1;

public interface TestInterfaceClass3 {
	public abstract void abMethod();

}

package com.wangxing.interfacedemo1;

public class SonTestInterfaceClass3 implements TestInterfaceClass3 {
	public  void abMethod(){
		System.out.println("接口的子类重写接口的抽象方法");
	}

}

     主方法：

package com.wangxing.interfacedemo1;

public class InterfaceMain3 {

	public static void main(String[] args) {
		PuTongClass3 p3=new PuTongClass3();
		TestInterfaceClass3 interf3=new SonTestInterfaceClass3();
		p3.TestPuTong(interf3);
		
	}

}

5.21.抽象类与接口的区别

抽象类	接口
abstract  class	interface
extends 一个	implments  一个/多个
体现出java的重构,抽象类的子类往往都是同一种事物	体现出java的扩展,接口的子类往往都是不同种类事物
抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。	接口中可以有类变量、类方法、抽象方法。且都是public修饰符修饰的。
抽象方法可以有页可以没有	接口中大部分都是抽象方法

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