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