类的继承以及抽象类和接口的概念
继续上次类的内容继续写。
这次主要说的是类的继承、抽象类以及接口的概念。
一、类的继承
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;//CDpublic 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是接口名
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！