继续上次类的内容继续写。
这次主要说的是类的继承、抽象类以及接口的概念。
一、类的继承
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是接口名
相关推荐
Java抽象类和接口是两种不同的概念，它们之间存在着继承关系。在Java中，抽象类（abstract class）和接口（interface）都是用来描述对象的行为和状态的，但它们之间有着明显的区别。 首先，让我们来看一下抽象类。...
5. **实现要求**：继承抽象类的子类必须实现所有抽象方法；实现接口的类必须实现接口中的所有方法。 #### 六、示例代码 以下是一个简单的示例，展示了基本类、抽象类和接口的基本用法： ```java // 基本类示例 ...
在这个系统中，"表面积和体积_抽象类Shape_shape类继承_"这个主题涉及到的是OOP中的一个重要概念——抽象类和类的继承。 首先，让我们来理解抽象类（Abstract Class）。抽象类是一种特殊的类，它不能被实例化，主要...
5. 接口可以有多重继承，而类只能单继承抽象类。 现在，让我们看看抽象类和接口的相同点和区别： 相同点： 1. 都可以被继承，为派生类提供共享的行为和属性。 2. 都不能被实例化，只能作为其他类的基础。 3. 都...
Java 类、抽象类、接口和继承是面向对象编程的核心概念，它们构成了 Java 语言的基石。在 Java 中，类是用来封装数据和行为的结构，而对象则是类的实例，具有具体的属性和行为。 1. **类与对象的区别** 类是模板...
在Java编程语言中，抽象类和接口是两种重要的面向对象设计概念，它们允许我们定义规范，供其他类去实现或继承。在这个练习中，我们将深入理解这两种机制，并通过实际的代码示例和注释来加深理解。 首先，让我们讨论...
在本章中，我们将详细介绍 Java 中的类继承、抽象类和接口这些重要概念。 类继承 类继承是面向对象编程的重要特点之一，它使得能够在已有的类的基础上构造新的类，新类除了具有被继承类的属性和方法外，还可以根据...
本主题将深入探讨如何使用普通类、接口和抽象类来实现这些继承方式，并应用到“增、删、改、查”（CRUD，Create, Read, Update, Delete）操作中。 首先，单继承是指一个子类只能继承一个父类的特性。这种方式使得...
- **抽象类**：继承抽象类使用`extends`关键字。 - **接口**：实现接口使用`implements`关键字。 这反映了两者在概念上的不同定位：抽象类强调的是“是什么”的关系（例如，狗是动物的一种），而接口强调的是“能做...
在C#编程语言中，抽象类和接口是实现面向对象编程（OOP）中的多态性和代码重用的关键概念。本文将深入探讨这两个概念，并解释它们在C#中的使用方式和区别。 ### 抽象类 抽象类是一种特殊的类，它不能被实例化，其...
在编程世界中，接口、内部类和抽象类是面向对象设计的重要组成部分，它们各自具有独特的功能和用途。本文将深入探讨这些概念以及它们之间的区别。 首先，我们来了解**接口**。接口在Java中是一种完全抽象的类型，它...
### 抽象类和接口的区别分析 在面向对象编程中，抽象类与接口都是实现代码复用和提高软件模块化的重要工具。它们各自拥有独特的特性和应用场景，掌握这些概念对于编写高质量、可维护性强的代码至关重要。下面我们将...
在C#编程语言中，抽象类和接口都是用于实现面向对象编程中多态特性的关键概念。它们都旨在为其他类提供一种定义行为和特性的模板或规范，但它们之间存在着重要的区别。本文将详细探讨C#中的抽象类与接口之间的差异，...
总结来说，类的继承允许我们构建层次结构，抽象类为共享接口提供了模板，而虚方法则允许子类定制和扩展行为。这些概念共同构成了面向对象编程的强大工具箱，使我们能够构建可维护、可扩展的软件系统。
在编程领域，抽象类和接口是面向对象设计中的两个重要概念，它们用于实现代码的抽象和多态性。本实验旨在帮助你深入理解和熟练运用这两种机制。 首先，让我们来看看抽象类。抽象类是一种不能被实例化的类，它通常...
在软件开发中，接口和抽象类是两个常用的概念，但它们之间的区别却让许多人感到困惑。那么，什么是抽象类和接口？它们之间有什么区别？下面，我们就来详细地探讨这个问题。 一、抽象类 抽象类是一种特殊的类，它不...
在Java编程语言中，抽象类和接口是两种重要的面向对象设计概念，它们允许我们定义规范，为其他类提供模板或行为指南。让我们深入探讨这两个概念及其在Java中的应用。 首先，我们来理解抽象类。在Java中，抽象类是一...