java的继承 多态 类和接口

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

定义动态二维数组方法：

方式一：

数据类型[][] 变量名 = 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"的关系。接口定义的是扩展功能。

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