[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-perPRPgq-1608641067105)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222001641906.png)]
卸载和安装JDK
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYnXvbAn-1608641067107)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222001805046.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4KQ1Ie9x-1608641067110)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222002723760.png)]
第一个hello，word程序[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7ZO5eF5-1608641067111)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222094909864.png)]
Ctrl 加insert复制
shift加insert粘贴
public class hello{
public static void main(String[] args){
System.out.print("Hello,World!");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3sucdYRf-1608641067112)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222095842464.png)]
标识符注意点- 所有的标识符都应该以字母(A-Z 或者a-z) ,美元符($)、或者下划线( )开始
- 首字符之后可以是字母(A-Z 或者a-z) ,美元符($) 、下划线(或数字的任何字符组合
- 不能使用关键字作为变量名或方法名。
- 标识符是大小写敏感的
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音,很Low
- 位(bit) :是计算机内部数据储存的最小单位，11001100是一 个八位二进制数。
- 字节(byte) :是计算机中数据处理的基本单位，习惯上用大写B来表示,
- 1B (byte,字节) = 8bit (位)
- 字符:是指计算机中使用的字母、数字、字和符号
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gxmcm4g7-1608641067113)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110344066.png)]
boolean不能进行数据转换其他数据类型为字节单位，boolean是以位为单位
浮点数拓展
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IVccue9F-1608641067114)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110613641.png)]
银行中的应用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y7lZwlrj-1608641067115)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222110859787.png)]
类型转换[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fPdSKPrJ-1608641067116)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222111856239.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMPPYrXB-1608641067117)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222112123644.png)]
低-------------------------------> 高 byte, short,char-> int -> long-> float -> double
String不是基本的数据类型
变量和常量变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o7i20k9e-1608641067118)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222112937451.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cdZh5cIA-1608641067119)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222113352348.png)]
变量的命名规范
- 所有变量、方法、类名：见名知义
- 类成员变量:首字母小写和驼峰原则: monthSalary
- 局部变量:首字母小写和驼峰原则
- 常量:大写字母和下划线: MAX_ VALUE
- 类名:首字母大写和驼峰原则: Man, GoodMan
- 方法名:首字母小写和驼峰原则: run(), runRun()
位运算符<<、>>效率极快
字符串连接符+System . out .println("" +a+b);//""先和a拼接，在和b拼接，a+b不进行算术运算
System . out. println(a+b+"");//a+b先进行算术运算，在和""拼接
-
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
-
包语句的语法格式为:
package pkg1[. pkg2[. pk...]]; -
一般利用公司域名倒置作为包名;com.wdl.base
-
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可 完成此功能
import package1[. package..].(classname |*);
- javadoc命令是用来生成自己API文档的
- 参数信息
- @author作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param参数名
- @return 返回值情况
- @throws 异常抛出情况
- 用IDEA构建javadoc
https://www.cnblogs.com/noKing/p/8006298.html
用户交互Scanner(获取用户的输入)next()和hasNext()
public class Demo02_Scanner {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收: ");
//判断用户有没有输入字符串
if (scanner.hasNext()){
//使用next方式接收
String str = scanner.next();//程序会等待输入内容，不输入会卡在这里
System.out.println("输出的内容为: "+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
scanner.close();
}
}
nextLine()和hasNextLine()
public class Demo02_Scanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收: ");
//判断是否还有输入
if (scanner.hasNextLine()) {
String str = scanner.nextLine();
System.out.println("输出的内容为: " + str);
}
scanner.close();
}
}
next()和nextline()的区别
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKFAhLJ3-1608641067120)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222132536621.png)]
switch语句[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CphiOLXQ-1608641067121)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222134426179.png)]
do-while(注意while后面的分号)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mE7rVfxJ-1608641067121)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222142429380.png)]
break和continue的区别[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BlbOruhX-1608641067122)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222144458031.png)]
三角形的打印[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xhP1Pbis-1608641067123)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222145112027.png)]
方法的重载-
重载就是在一个类中，有相同的函数名称，但形参不同的函数。
-
方法的重载的规则:
- 方法名称必须相同。
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。(必须满足)
- 方法的返回类型可以相同也可以不相同。
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AhDtFw7k-1608641067123)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222150754110.png)]
- 仅仅返回类型不同不足以成为方法的重载。
-
实现理论:
方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZtREBGc-1608641067124)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222151531483.png)]
可变参数(本质是数组)- JDK 1.5开始，Java支持传递同类型的可变参数（不定项）给一个方法。
- 在方法声明中，在指定参数类型后加一个省略号(…)。
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class Demo08 {
public static void main(String args[]) {
//调用可变参数的方法
printMax(15,22.0,36,25.3);
printMax(new double[]{1, 2, 3});//本质为数组
}
public static void printMax(double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
//排序!
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EpiDBUHQ-1608641067125)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222152846380.png)]
简易计算器package com.kuang.scanner;
import java.util.Scanner;
public class hello {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.print("请输入第一个数字：");
int num1 = s.nextInt();
System.out.print("请输入运算符：");
String operator = s.next();
System.out.print("请输入第二个数字：");
int num2 = s.nextInt();
int result = 0;
switch (operator) {
case "+":
result = num1 + num2;
break;
case "-":
result = num1 - num2;
break;
case "*":
result = num1 * num2;
break;
case "/":
result = num1 / num2;
break;
case "%":
result = num1 % num2;
break;
default:
System.out.println("你的输入不合法！！！");
}
System.out.println(num1 + operator + num2 + "=" + result);
}
}
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:
dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 -
Java语言使用new操作符来创建数组，语法如下:(前后数据类型必须一致)
dataType[] arrayRefVar = new dataType[arraySize] ; -
数组的元素是通过索引访问的,数组索引从0开始。
二维数组的输出
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RFkyoqjQ-1608641067126)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222164548450.png)]
内存分析—三种初始化[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8pA8ijqW-1608641067127)(D:\image-20201222155715184.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-98hEQl4e-1608641067128)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222155834796.png)]
冒泡排序(小升级)package com.kuang.scanner;
import java.util.Arrays;
public class hello {
public static void main(String[] args) {
int[] a = {1, 4, 5, 6, 72, 2, 2, 2, 25, 6, 7};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次;
for (int i = 0; i < array.length - 1; i++) {
Boolean flag = false;
//内层循环，比价判断两个数，如果第一个数，比第二个数大,则交换位置(相邻两个数之间的比较)
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] > array[j]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8XN55TQL-1608641067128)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222165501101.png)]
package com.kuang.scanner;
public class hello {
public static void main(String[] args) {
//创建一个元素的二维数组 11*11 0：没有棋子 1： 黑棋 2： 白棋
int chessArry1[][] = new int[11][11];
chessArry1[1][2] = 1;
chessArry1[2][3] = 2;
for (int [] row : chessArry1) {
for ( int data : row) {
System.out.printf("%d\t", data);
}
System.out.println();
}
int[][] paraseArr = transformSparseArr(chessArry1);
transformArry(paraseArr);
}
//二维数组 转 稀疏数组
public static int[][] transformSparseArr( int[][] arry) {
int sum =0; // 有效值的个数
int rowSize = 0;
//1、计算出有效的个数
for (int[] row :arry) {
for ( int data :row) {
rowSize = row.length;
if (data != 0) {
sum++;
}
}
}
//创建稀疏数组 并给稀疏数组赋值
int [][] sparseArr= new int[sum+1][3];
sparseArr [0][0] = arry.length;
sparseArr [0][1] = rowSize;
sparseArr [0][2] = sum;
//count 计数器 计算放入的有效个数 即第几个非零数据
int count = 0;
for (int i = 0; i < arry.length; i++) {
for (int j = 0; j < rowSize ; j++) {
if (arry[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = arry[i][j];
}
}
}
// 输出稀疏数组形式
System.out.println("===========稀疏数组============");
for (int i = 0; i < sparseArr.length; i++) {
// %d 占位符 \t 制表符 \n 换行
System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
}
System.out.println();
return sparseArr;
}
// 稀疏数组 转化为 二维数组
public static int[][] transformArry(int[][] parseArr) {
int row = parseArr[0][0]; //得到行
int col = parseArr[0][1]; //得到列
//数组恢复 并赋值
int[][] arry = new int[row][col];
for (int i = 1 ; i < parseArr.length; i++) {
arry[parseArr[i][0]][parseArr[i][1]] = parseArr[i][2];
}
// 输出
System.out.println("============二维数组恢复==============");
for (int [] rows: arry) {
for (int data : rows) {
System.out.printf("%d\t", data);
}
System.out.println();
}
return arry;
}
}
面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据
三大特性:
- 封装
- 继承
- 多态
方法调用
静态方法
可以通过类直接调用，在类加载时加载，不能调用非静态方法
public class Demo01Static {
public static void main(String[] args) {
Student.say();
}
}
public class Student {
public static void say(){
System.out.println("学生说话了");
}
}
非静态方法
通过实例化对象调用
public class Demo01Static {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
public class Student {
public void say(){
System.out.println("学生说话了");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0UWi3Mdr-1608641067129)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222184401007.png)]
自动生成返回值按快捷键ctrl+alt+v
构造器-
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写void
-
构造器必须要掌握
public class Person { //一个类即使什么都不写，它也会存在个方法 //显示的定义构造器 String name ; int age; //alt+ insert 可以快捷生成构造器 //1.使new关键字， 本质是在调用构造器 //2.用例初始化值 public Person(){ } //有参构造:一旦定义 了有参构造。无参就必须显示定义，否则调用无参构造器时程序会报错 public Person(String name){ this.name = name ; } public Person(String name, int age) { this. name = name; this.age = age; } }-
构造器:
- 和类名相同
- 没有返回值
-
作用:
- new本质在调用构造方法
- 初始化对象的值
-
注意点:
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
-
Alt加insert
默认生成有参，select none生成无参
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Fb1eqig-1608641067130)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222183536201.png)]
创建对象内存分析[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XqzJnKlN-1608641067131)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222184200492.png)]
封装属性私有，get/set
可以提高安全性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GrVBgpI4-1608641067132)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222185047275.png)]
继承- extands的意思是“扩展”。子类是父类的扩展。
- JAVA中类只有单继承，没有多继承!
- 被final修饰的类不能被继承。
object类
java中的所有类都直接或间接继承Object类
Ctrl加H
可以查看当前类的继承树
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bpOTtWOC-1608641067133)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222185819780.png)]
super
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMs7rmIH-1608641067134)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222190340430.png)]
可以省略
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ibzw3KLw-1608641067134)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222190857594.png)]
- super注意点:
- super调用 父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this 不能同时调用构造方法!
- Vs this:
- 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用
- 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用
- 构造方法 this() ; 本类的构造 super():父类的构造!
父类静态方法
public class Demo04_A extends Demo04_B{
public static void test(){
System.out.println("A==>test()");
}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
public static void test(){
System.out.println("B==>test()");
}
}
public class Applications {
public static void main(String[] args) {
//Demo04
//方法的调用只和左边，定义的数据类型有关
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();
b.test();//B==>test()
}
}
父类非静态方法
public class Applications {
public static void main(String[] args) {
//Demo04
/*
静态方法和非静态方法区别很大
静态方法：方法的调用只和左边，定义的数据类型有关
非静态方法：重写，父类方法只能是public
*/
Demo04_A a = new Demo04_A();
a.test();//A==>test()
//父类引用指向引用
Demo04_B b = new Demo04_A();//子类重写了父类的方法
b.test();//A==>test()
}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {
public void test(){
System.out.println("B==>test()");
}
}
public class Demo04_A extends Demo04_B{
@Override
public void test() {
System.out.println("A==>test()");
}
}
重写:需要有继承关系，子类重写父类的方法!
- 方法名必须相同
- 参数列表列表必须相同
- 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private
- 抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)
- 重写，子类的方法和父类必要一 致;方法体不同!
- 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
- 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
- 多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 注意:多态是方法的多态，属性没有多态性。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v7cw29Ei-1608641067135)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222193111508.png)]
public class Person {
public void run(){
System.out.println("Person==>run()");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("Student==>run()");
}
public void stop(){
System.out.println("Student==>stop()");
}
}
public class Applications {
public static void main(String[] args) {
// 一个对象的实际类型是确定的:new Student();new Person();
//可 以指向的引用类型就不确定了:父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的!
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
s2.run(); //子类重写了父类的方法。执行子类的方法 Student==>run()
s1.run();//Student==>run()
s1.stop();//Student==>stop()
Person p1 = new Person();
p1.run();//Person==>run()
}
}
多态注意事项:
- 多态是方法的多态，属性没有多态
- 父类和子类，有联系 类型转换异常! ClassCastException!
- 存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
- 不能进行多态的方法：
- static 方法，属于类，它不属于实例
- final常量;
- private 方法;|
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XUuDcV9Z-1608641067136)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222194544016.png)]
- 父类转子类
public class Application {
public static void main(String[] args) {
//类型之间的转化:父子
//高 低
Person obj = new Student();
//student将这个对象转换为Student类型，我们就可以使student类型的方法了!
((Student) obj).go();
}
}
-
子类转父类
public class Application { public static void main(String[] args) { //类型之间的转化:父 子 //子类转换为父类，可能丢失自己的本来的一些方法! Student student = new Student(); student.go(); Person person = student; } }
(类型转换)引用类型， 判断一个对象是什么类型~
public class Applications {
public static void main(String[] args) {
Object object = new Student();
//System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系
//System. out . println(X instanceof Y);// X是Y之的子类，true
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //False
System.out.println(object instanceof String); //False
System.out.println("===========================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //False
//System.out.println(person instanceof String); //不能通过编译
System.out.println("===========================");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //不能通过编译
//System.out.println(student instanceof String); //不能通过编译
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0W7YHhFH-1608641067136)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222195218953.png)]
静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class He {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
- abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如果修饰类，那么该类就是抽象类。
- 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
- 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。
- 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
- 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。
- 方法public abstract 按口中的所有定义的方法其实都是抽象的public abstract
- 常量public static final 常量~ pubsic static final,一般不在接口中定义常量
- 接口不能被实例化，接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法~
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-elmxMHA3-1608641067137)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222202516006.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yX2Pyjwq-1608641067138)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222202615165.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cW9WQllf-1608641067140)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222203450684.png)]
Ctrl加Alt加T[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DEIT6TuG-1608641067141)(C:\Users\王东梁\AppData\Roaming\Typora\typora-user-images\image-20201222203136221.png)]
