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.object.test1;
//FatherClass抽象类
public abstract class FatherClass {
          public int num=100; //实例变量
          public static String name="zhangsan";  //静态成员变量
          
          //构造方法
          public FatherClass(){
        	  System.out.println("构造方法");
          }
          //实例方法
          public void shilimethod(){
        	  System.out.println("实例方法");
          }
          //静态方法
          public static void  staticmethod(){
        	  System.out.println("静态方法");
          }
          //抽象方法
          public abstract void abstractmethod();
           
}


package com.object.test1;
//FatherClass抽象类的子类
public class SonClass extends FatherClass {
	
	 public  void abstractmethod(){
		 
	 }
}




//测试抽象类
package com.object.test1;

public class TestMain {

	public static void main(String[] args) {
		SonClass scl=new SonClass();
		scl.staticmethod();
		scl.shilimethod();
		System.out.println( scl.num);
		System.out.println(scl.name);

	}

}

4.抽象类的具体用法

1.抽象类不能new，需要借助子类访问抽象类中的实例元素

2.普通的java类继承了抽象类，就需要重写所继承的抽象类中的所有抽象方法，否则普通的

java类将会改为抽象类

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

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

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

【抽象方法实际上是子类重写以后的方法】。

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

类的子类对象

package com.object.test3;
public class Person {
	//当某一个普通的java类中的方法参数是抽象类类型
	  public  void  testPerson(FatherClass fac){
           System.out.println("Personl实例方法");
           fac.fathermethod();
	  }
}



package com.object.test3;
//FatherClass抽象类
public abstract class FatherClass {
	      //抽象方法
          public  abstract void fathermethod();
           
}



package com.object.test3;
//FatherClass抽象类的子类
public class SonClass extends FatherClass {
	
	 public void fathermethod(){
		 System.out.println("SonClass子类重写父类TestClass的抽象方法");
	 }
}




package com.object.test3;

public class TestMain {

	public static void main(String[] args) {
		//抽象类不能new
		//new TestClass();
		//如果我们需要创建出抽象类的对象，就需要借助上转型对象
		//上转型对象--子类的对象赋值给父类的变量
		//FatherClass  facl =new SonClass();
		//facl.fathermethod();
		
		Person per=new Person();
		//FatherClass fcl=new SonClass();//上转型对象
		//per.testPerson(fcl);  
		SonClass scl=new SonClass();
		per. testPerson(scl);

	}

}

 5.上转型对象

上转型对象---子类的对象赋值给父类的变量，此时子类对象向上转型为父类对象

上转型对象不能访问子类本身创建的的变量和方法，只能通过强制类型转换来进行访问

package com.object.test2;
//FatherClass抽象类
public abstract class FatherClass {
          //实例方法
          public void fathermethod(){
        	  System.out.println("抽象类父类的实例方法");
          }
         
           
}


package com.object.test2;
//FatherClass抽象类的子类
public class SonClass extends FatherClass {
	
	public void sonmethod(){
  	  System.out.println("抽象类的子类的实例方法");
    }
}



//测试抽象类用法
package com.object.test2;

public class TestMain {

	public static void main(String[] args) {
		//上转型对象--子类的对象赋值给父类的变量，此时子类对象就向上转型成父类对象
		FatherClass scl=new SonClass();
		scl.fathermethod();
		//上转型对象不能方法子类本身的变量和方法
		//scl.sonmethod();//错误的
		SonClass son=(SonClass)scl;
		son.fathermethod();//父类
		son.sonmethod();//子类

	}

}

6.卖水果实例

package com.object.test4;
//创建水果抽象类
//提供同一种类型事物的公共内容
public abstract class  Fruit {
          public abstract void eat();
}

package com.object.test4;

public class Banana extends Fruit{
	 public  void eat(){
		 System.out.println("我是香蕉，剥完皮再吃!");
	 }
}

package com.object.test4;

public class Apple extends Fruit{
	 public  void eat(){
		 System.out.println("我是苹果，削皮再吃哦!");
	 }
}

package com.object.test4;

public class Farm {
       //创建一个静态方法
	public  static  Fruit sellFruit(String name){
		Fruit  sg=null;
		if(name.equals("苹果")){
			sg=new Apple();
		}
		if(name.equals("香蕉")){
			sg=new Banana();
		}
		return sg;
}
}

package com.object.test4;
import java.util.Scanner;
public class TestMethod {
	
	public static void main(String[] args) {
		System.out.println("你好，你需要点什么?");
		Scanner  input=new Scanner(System.in);
		String name=input.next();
		Fruit  sg= Farm.sellFruit(name);
		sg.eat();
	}

}