类的继承以及抽象类和接口的概念

继续上次类的内容继续写。

这次主要说的是类的继承、抽象类以及接口的概念。

一、类的继承

     1.概念

        Java里类的继承主要是通过关键字extends来写的。继承后，子类(儿子)将继承父类(父亲)的成员属性和成员方法。

     2.格式

        public class 父类名{}

        public class 子类名 extends 父类名{}

     3.作用

        1）反映现实中类与类的真实关系

        2）子类继承父类的属性和方法，减少代码的冗余

        3）子类可以在父类的基础上增加新的方法以及修改继承来的方法

             注意：子类可以在父类的基础上，定义自己特有的 属性和方法【扩展】。但是子类特有的属性和方法必须是子类类型的对象才能调用

     4.类型的转换

        类类型的转换和数据的类型装换是一样的，可以是自动装换，也可以是强制转换

       自动转换必须是从小往大装换；强制装换则是从大往小装换

       自动转换：子类对象的类型自动转换成父类类型

       强制转换：父类类型的对象必须强制转换才能转换成子类类型

     5.方法的重写和重载

        重写：在同一个类中，有多个同名不同参数列表【参数的类型、个数或者顺序】，且方法体必须不同的方法

        重载：在子类重新定义一个和父类同方法名、同参数、同返回值且方法体不同的方法

     6.注意事项

        构造方法不能被继承，只能被调用

        在子类子类的构造方法中必须调用父类的一个构造方法，一般没写的话就默认调用的是父类的无参构造方法

        如果父类存在构造方法的重载，那么父类默认的无参构造方法就会失效，解决方法是直接写出来。

        

       Java中是单根继承，每个类只有一个父类，除了最高层次的根类:Object类。其他所有的类都是Object类的子类，包括数组

 

      7.多态

          概念：同一个类型的对象执行相同的行为，得到的结果可能不一样

          表现形式:

  1、重写多态:[动态多态]由于继承和重写机制，相同类型的对象，调用相同的方法，得到的结果可能出现多种情况

  2、重载多态:[静态多态]由于重载机制，可以导致的多态

 

/**
 * 汽车类Auto类
 * @author LiuQingjian
 *
 */
public class Auto {
	//轮胎个数
	public int lt;
	//汽车颜色
	public String color;
	//汽车重量
	public double wei;
	//汽车的速度
	public double v;

	/**
	 * 构造方法初始值
	 */
	public Auto() {
		lt = 0;
		color = "白色";
		wei = 0;
		v = 0;
	}
	/**
	 * 重载构造方法初始值
	 */
	public Auto(int t) {
		lt = t;
		color = "白色";
		wei = 0;
		v = 0;
	}
	/**
	 * 重载构造方法初始值
	 */
	public Auto(int t, String s) {
		lt = t;
		color = s;
		wei = 0;
		v = 0;
	}
	/**
	 * 重载构造方法初始值
	 */
	public Auto(int t, String s, double p) {
		lt = t;
		color = s;
		wei = p;
		v = 0;
	}
	/**
	 * 重载构造方法初始值
	 */
	public Auto(int t, String s, double p, double a) {
		lt = t;
		color = s;
		wei = p;
		v = a;
	}
	/**
	 * 加速方法
	 * @param t 加速的速度
	 */
	public void js(int t) {
		System.out.print(v);
		v += t;
		System.out.println("加速成了" + v);
	}
	/**
	 * 减速方法
	 * @param t 减速的速度
	 */
	public void js1(int t) {
		System.out.print(v);
		v += t;
		System.out.println("减速成了" + v);
	}
	/**
	 * 停车的方法
	 */
	public void stop() {
		v = 0;
		System.out.println("已停车");
	}
	/**
	 * 输出汽车此时的状态
	 */
	public void setter() {
		System.out.println("该车有" + lt + "个轮子");
		System.out.println("该车的颜色是:" + color);
		System.out.println("该车重" + wei + "吨");
		System.out.println("该车此时速度:" + v + "km/s");
	}
}
/**
 * 汽车配置类Car类
 * @author LiuQingjian
 *
 */
public class Car extends Auto {
	//空调
	public String kt;
	//CD
	public String cd;
	/**
	 * 构造方法，初始值
	 * @param t 轮胎个数
	 * @param s 汽车颜色 
	 * @param p 汽车重量
	 * @param c 汽车速度
	 * @param a 汽车内的空调
	 * @param b 汽车内的CD
	 */
	public Car(String a, String b) {
		super(4, "绿色", 30, 6);
		kt = a;
		cd = b;
	}
	/**
	 * 重写加速方法
	 */
	public void js(int t) {
		v += t;
		System.out.println("v已加速:" + v + "km/s");
	}
	/**
	 * 重写减速方法
	 */
	public void js1(int t) {
		v -= t;
		System.out.println("v已减速:" + v + "km/s");
	}
	/**
	 * 输出此时汽车的状态与配置
	 */
	public void setter() {
		System.out.println("该车有" + lt + "个轮子");
		System.out.println("该车的颜色是:" + color);
		System.out.println("该车重" + wei + "吨");
		System.out.println("该车此时速度:" + v + "km/s");
		System.out.println("该车装有" + kt);
		System.out.println("该车上有" + cd);
	}
}
/**
 * 主类
 * @author LiuQingjian
 *
 */
public class de {
	public static void main(String[] args) {
		Auto ca = new Auto();
		Auto ca1 = new Auto(4);
		Auto ca2 = new Auto(4, "黑色");
		Auto ca3 = new Auto(4, "灰色", 20);
		//创建汽车
		Auto ca4 = new Auto(4, "绿色", 30, 6);

		ca4.stop();
		ca4.js(4);
		ca4.js1(1);
		ca4.setter();

		//创建新的有配置的汽车
		Auto ca5 = new Car("美的空调", "歌唱CD");
		ca5.setter();
		ca5.js(5);
		ca5.js1(3);
		ca5.setter();
	}
}

 

 

 

 二、抽象类

       1.类的特点：

          类中的方法必须全部是具体的方法[有方法体的方法],类中的方法可以是成员方法,也可以是类方法

          类中的属性可以是成员属性，也可以是类属性

          类中至少有一个构造方法，可以调用构造方法来创建对象,默认的是无参构造方法

 

        2.[虚类]抽象类的关键字  abstract class

           1）抽象类的定义格式

                public abstract class A{

                   private String name;

                   private static String age;

 

                   public void a(){

                   }

 

                   public abstract void b();

                   public abstract void b(String s);

                }

 

        3.抽象类的特点

            抽象类中的方法可以是具体的方法，也可以是抽象方法[没有方法体的方法]

            抽象类中的属性可以是成员属性，也可以是类属性

            抽象类中的方法需要且必须定义访问限定符

            抽象类中至少有一个构造方法,但是不能调用构造方法来创建对象

            作用：抽象类就是用来充当父类，给子类去继承扩展和完善的

 

        4.抽象类的继承

            格式：public class [类名]B extends [类名]A{}

            继承抽象类必须要重写抽象类中的所有抽象方法

 

/**
 * 抽象类Vehicle类
 * @author LiuQingjian
 *
 */
public abstract class Vehicle {
	public abstract String NoOfWheels();
}
/**
 * 扩展抽象类的Motorbike类
 * @author LiuQingjian
 *
 */
public class Motorbike extends Vehicle {
	public String NoOfWheels(){
		System.out.println("一个双轮车");
		return "双轮车";
	}
}
/**
 * 扩展抽象类的Car类
 * @author LiuQingjian
 *
 */
public class Car extends Vehicle {
	public String NoOfWheels(){
		System.out.println("一个四轮车");
		return "四轮车";
	}
}
/**
 * 主类
 * @author LiuQingjian
 *
 */
public class de {
	public static void main(String[] args) {
		Car a = new Car();
		Motorbike b = new Motorbike();
		System.out.println(a.NoOfWheels());
		System.out.println(b.NoOfWheels());
	}
}

 

三、接口

      1.[纯虚类]接口的关键字  interface

          接口的定义

          public interface 接口名{}

 

       2.接口的特点：

          接口中的方法必须全部是抽象方法,默认就是public abstract,必须是public abstract,可以省略

          接口中的属性必须是常量,默认就是public static final，必须是public static final

          接口中没有构造方法，不能创建对象

          作用：接口是用来充当父类，给子类去扩展和完善的

 

       3.接口的实现

           public interface [接口名]A{}

           public class [接口名]B implements [接口名]A{}

          必须定义一个子类实现这个接口，并且要重写[实现]接口中的所有抽象方法

 

 

/**
 * 接口Vehicle
 * @author LiuQingjian
 *
 */
public interface Vehicle {
	/**
	 * 抽象方法
	 * @param t 输出值
	 */
	public abstract void start(int t);
	/**
	 * 抽象方法
	 * @param t 输出值
	 */
	public abstract void stop(int t);
}

/**
 * 实现接口,完善抽象类类
 * @author LiuQingjian
 *
 */
public class Bus implements Vehicle{
	/**
	 * 输出传来的值
	 */
	public void start(int t){
		System.out.println("t="+t);
	}
	/**
	 * 输出传来的值	
	 */
	public void stop(int t){
		System.out.println("t="+t);
	}
}

/**
 * 实现接口,完善抽象类Bike类
 * @author LiuQingjian
 *
 */
public class Bike implements Vehicle{
	/**
	 * 输出传来的值
	 */
	public void start(int t){
		System.out.println("t:"+t);
	}
	/**
	 * 输出传来的值
	 */
	public void stop(int t){
		System.out.println("t:"+t);
	}
}

/**
 * 主类
 * @author LiuQingjian
 *
 */
public class interfaceDemo {
	public static void main(String[] args) {
		Bike a = new Bike();
		Bus b = new Bus();
		a.start(10);
		a.stop(1);
		b.start(9);
		b.stop(2);
	}
}

 

 

扩展：

        1.常量的定义：public static final 数据类型 变量名 = 值;    

        2.不管是继承类，还是抽象类，还是接口，如果子类要重写父类的方法，都不能够减小方法的访问限定范围

            public   protected   默认不写   private          范围按顺序：大->小

        3.如果是抽象类继承抽象类,可以不用重写继承到的方法。

           抽象类实现接口，可以不用重写接口中的方法。

           原因：抽象类允许抽象方法存在。

        4.接口可以继承接口，一个接口可以继承多个接口，不能重写继承到的方法

          例： public interface C{}

          public interface D{}

          public interface E extends C,D{}

           附:C、D、E都是接口名

       5.类与类的继承，类与抽象类的继承都是单根继承

     

       6.一个类[抽象类]可以实现多个接口，

  例：public class F implements C,D{}

          附：F是类名，C、D是接口名

 

           一个类[抽象类]可以先继承一个类，再实现多个接口

  例：public class G extends A implements C,D{}

 

         G a1 = new G();

         A a2 = new G();

         C a3 = new G();

         D a4 = new G();

          例：G、A是类名，C、D是接口名