java的继承多态类和接口

墨蓝 2022-06-17 01:39 276阅读 0赞

###     ###

### 先说点小东西，会的请直接省略不看： ###

### 定义动态二维数组方法： ###

方式一：

数据类型\[\]\[\] 变量名 = new 数据类型\[m\]\[n\];

m表示这个二维数组有多少个一维数组  
n表示每一个一维数组的元素个数

方式二：

数据类型\[\]\[\] 变量名 = new 数据类型\[m\]\[\]；

注意：  
m这个数据必须给出，后面的数据可以不给

**定义静态二维数组方法：**

数据类型\[\]\[\] 变量名 = \{ \{元素…\},\{元素…\},\{元素…\}\};

一：冒泡排序  
1.1 看视频得出结论：  
  
  
1.2 冒泡排序基本概念是：  
相邻的两个元素进行比较，小的放前面，大的放后面  
  
  
1.3 画图讲解冒泡排序，int\[\] arr = \{ 24, 69, 80, 57, 13 \};  
  
  
1.4 文字分析比较过程  
第一次比较：比较了4次，最大的值放到了最后  
第二次比较：比较了3次，次大的值放到了倒数第二  
。。。依次类推

public class arraydemo \{  
public static void main(String\[\] args) \{  
Scanner sc = new Scanner(System.in);  
int k = 0;  
int \[\] chs = new int\[10\];  
while(k < 10)  
\{  
int s = sc.nextInt();  
chs\[k\] = s;  
k++;  
\}  
  
array1(chs);  
for (int i = 0; i < chs.length; i++) \{  
System.out.print(chs\[i\]+" ");  
\}  
\}  
public static void array1(int \[\] chs) \{  
for (int i = 0; i < chs.length-1; i++) \{  
for (int j = 0; j < chs.length-1-i; j++) \{  
if(chs\[j\]>chs\[j+1\])  
\{  
int temp = chs\[j\];  
chs\[j\] = chs\[j+1\];  
chs\[j+1\] = temp;  
\}  
\}  
\}  
  
  
\}  
  
  
\}

二：选择排序：  
2.1 选择排序概念：  
\* 选择排序：  
\* 从0索引开始，依次和后面的每一个元素进行比较  
\* 第一次比较完毕，最小值出现在了最小索引处  
\* 第二次比较完毕，次小值出现在了次小索引处  
\* ...  
\* 完毕后，就排序了。

**java的三大特性：继承 封装和多态**

**一继承：**

先说说继承，我的个人的见解就是继承就像儿子继承父亲的财产一样，遗嘱里面给你的你必须拿上，但是给其他人的，比如给你妹妹或你妈妈的你就不能拿上

了，这样就不合法了，java也是如此。

**说说他能继承些什么：**

**1**

继承者叫子类，给予者叫超类。

首先子类能继承超类的方法，类中的变量等，除非方法私有化，否则都可继承。

1.1  
如何表达这个关系呢?  
通过extends关键字可以实现类与类的继承  
  
  
格式：  
class 子类名 extends 父类名 \{  
  
\}  
  
  
父类：基类，超类  
子类：派生类  
  
  
需求：  
学生类：  
成员变量：name,age  
构造方法：无参,带参  
成员方法：getXxx()/setXxx(),eat(),sleep()  
  
  
老师类：  
成员变量：name,age  
构造方法：无参,带参  
成员方法：getXxx()/setXxx(),eat(),sleep()  
  
非继承版代码  
  
  
1.2  
需求：（需要加入方法重写）  
学生类：  
成员变量：name,age  
构造方法：无参,带参  
成员方法：getXxx()/setXxx(),eat(),sleep()  
  
  
  
  
老师类：  
成员变量：name,age  
构造方法：无参,带参  
成员方法：getXxx()/setXxx(),eat(),sleep()  
  
  
按照我们刚才对继承的概述，我们可以找一个父类。  
  
人类：  
成员变量：name,age  
构造方法：无参,带参  
成员方法：getXxx()/setXxx(),eat(),sleep()  
  
  
学生类：继承人类就可以了。  
老师类：继承人类就可以了。  
  
  
继承的好处：  
A:提高了代码的复用性  
多个类相同的成员可以放到同一个类中  
B:提高了代码的维护性  
如果功能的代码需要修改，修改一处即可  
C:让类与类之间产生了关系，是多态的前提  
  
方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：  
1.必须存在继承关系  
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能

1.3  
继承的特点：（代码演示）  
A:Java只支持单继承，不支持多继承。  
B:Java支持多层(重)继承(继承体系)。  
  
  
什么时候使用继承呢?  
继承中类之间体现的是：”is a”的关系。  
  
  
采用假设法。  
举例：水果，香蕉  
举例：水杯，水果 (不能采用继承。)  
举例：动物，狗

附加：

访问超类中的方法：super.成员方法()父类的成员方法

访问本身类中的方法：this.成员方法()本身中的成员方法

**2 多态的描述**

**多态：同一个对象,在不同时刻表现出来的不同状态**

多态的前提：  
A:有继承关系  
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）  
C:有父类引用指向子类对象  
  
  
Fu f = new Fu();  
  
  
左边：Fu类型的引用  
右边：Fu类型的对象  
  
  
Zi z = new Zi();  
  
  
Fu f = new Zi();  
  
3.2  
成员访问特点  
A:成员变量  
编译看左边,运行看左边  
B:构造方法  
子类构造默认访问父类的无参构造  
C:成员方法（重点理解）  
编译看左边,运行看右边  
  
  
为什么变量和方法不一样呢?  
方法重写。  
D:静态成员方法  
编译看左边,运行看左边  
因为静态的内容是和类相关的，与对象无关。

**三 接口的实现过程：**

1认识接口：不是我们现实生活中的usb接口等等实物的接口，类实现接口代表着这个类自身功能的一种扩展，  
所以接口代表着一种扩展的能力  
  
2  
接口的特点：  
A:定义接口要用关键字interface表示  
格式：interface 接口名 \{\}  
B:类实现接口用implements表示  
格式：class 类名 implements 接口名 \{\}  
C:接口不能实例化  
那么，接口如何实例化呢?  
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。  
D:接口的实现类  
要么是抽象类  
要么重写接口中的所有抽象方法  
  
  
多态的前提：  
A:有继承或者实现关系  
B:有方法重写  
C:有父类引用或者父接口引用指向子类或者实现类对象  
  
  
多态分类：  
A:具体类多态  
B:抽象类多态  
C:接口多态  
  
3  
接口的成员特点：  
A:成员变量  
只能是常量。  
默认修饰符：public static final  
B:构造方法  
没有构造方法  
C:成员方法  
只能是抽象方法。  
默认修饰符：public abstract  
  
4  
类与类：  
继承关系。只能单继承，可以多层(重)继承。  
  
类与接口：  
实现关系。可以单实现，也可以多实现。  
还可以在继承一个类的同时实现多个接口。  
  
  
接口与接口：  
继承关系。可以单继承，也可以多继承。  
5  
接口和抽象类的关系最后分析：  
抽象类和接口的区别  
A:成员区别  
抽象类：  
成员变量：可以是变量，也可以是常量  
构造方法：有构造方法  
成员方法：可以是抽象方法，也可以是非抽象方法  
接口：  
成员变量：只能是常量。默认修饰符 public static final  
成员方法：只能是抽象方法。默认修饰符 public abstract  
B:关系区别  
类与类：  
继承关系。只能单继承，可以多层(重)继承。  
  
类与接口：  
实现关系。可以单实现，也可以多实现。  
还可以在继承一个类的同时实现多个接口。  
  
  
接口与接口：  
继承关系。可以单继承，也可以多继承。  
  
C:设计理念区别  
抽象类被继承体现的是："is a"的关系。抽象类定义的是共性功能。  
接口被实现体现的是："like a"的关系。接口定义的是扩展功能。

**大概就是这些，希望能帮到各位。有遗漏的地方还请不辞吝教！多谢！**