继续上次类的内容继续写。
这次主要说的是类的继承、抽象类以及接口的概念。
一、类的继承
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是接口名