java网课。

Java网课
0902：
【1】具体dos命令；
（1）切换盘符：c: d: e: 大小写不区分
（2）显示详细信息：dir
（3）改变当前目录：cd
（4）当前目录 .
上一级目录 …
（5）清屏：cls
（6）切换历史命令：上下箭头
（7）补全命令：tab按键
（8）创建目录：md
删除目录：rd
（9）复制文件命令：copy
（10）删除文件：del
del后面如果接的是文件夹/目录：那么删除的就是这个文件夹下的文件，
而不是文件夹。

【2】程序中的常见问题
一个源文件中可以有多个类，只能由一个类被public修饰，源文件的名字必须跟public修饰的那个类名保持一致。
多个类会产生独立的字节码文件。
javac HelloWorld.java
执行的时候执行各自独立的字节码文件即可。
java HelloWorld
java Helloworld2

【3】文档注释
/**
@author liuqin
@version 1.0
这是我们第一章文档注释的代码，比较重要
*/
E：MyJava-code>javadoc -d myHello -author -version Helloworld.java

【4】字符
一个变量被final修饰，这个变量就变成了一个常量，其值不可变。
字符常量的值全部大写。

【5】cin>>
文字扫描器 import java.util.Scanner;
Scanner sc=new Scanner(System.in);
int r=sc.nextInt();
【6】运算符
‘6’表示一个字符，实际上是56.
“6”表示一个字符串，没有数字含义。

a+=b 运算效率搞，底层自动类型转换

&逻辑与 两边都判断
&&短路与 只要左边确定是false,右边就跳过而直接是false

^两边相同为false,不相同为true

<<左移两位相当于乘四，左移三位相当于乘八。

【7】数组。
静态初始化：直接在定义数组的同时就为数组元素分配空间并赋值。
int[] arr={12,23,34};
int[] arr=new int[]{12,34,45};

new int[3]{12,34,56} —>错误。
int arr;
arr={12,34,45} —>错误。

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] arr=new int[3];
arr[0]=12;
arr[1]=23;
arr[2]=45;

【8】Eclipse 和IDEA
Eclipse中workspaces相当于IDEA中的Project.
Eclipse中Project相当于IDEA中的Module.

在IntelliJ IDEA中Project是最顶级的级别，次级别是Module(模块）。
一个Project下可以有多个Module.

out目录存放编译后的文件。

删除模块先remove，后delete。

【9】IDEA常用设置
手动导包：new Date(); 快捷键alt+enter.
自动导包和优化多余的包。

【10】常用快捷键
创建内容：alt+insert
main方法：psvm
输出语句：sout
复制一行：ctrl+d
删除一行：ctrl+y
代码向上/下移动：ctrl+shift+up/down
搜索类：ctrl+n
生成代码：alt+insert(如构造函数等，getter,setter,hashcode,equals,tostring)
百能快捷键：alt+enter(导包，生成变量等）
单行注释或多行注释：ctrl+/或ctrl+shift+/
重命名： shift+f6
for循环 直接：for回车即可。
代码块包围：try-catch,if,while等 ctrl+alt+t
代码自动补全提示：
代码一层一层调用的快捷键：
显示代码结构：alt+7
显示导航栏：alt+7
缩进和取消缩进：tab shift+tab

【11】代码模板
Live templates中可以做用户的个性化定制。
Postfix Completion 中只能用，不能修改。

live templates 直接键入。Postfix completion , aaa.fori 作为后缀键入。

【12】常用代码模板
main方法：main或者psvm.
输出语句：sout或者.sout 一些变型：soutp:打印方法的形参 soutm:打印方法的名字 soutv:打印变量
循环：普通for循环：fori(正向) 或者.fori(正向) .forr(逆向）
增强for循环：iter 或者 .for（可以用于数组的遍历，集合的遍历）
条件判断：ifn或者.null: 判断是否为null(if null)
inn或者.nn:判断不等于null(if not null)
属性修饰符：prst:private static final
pst:public static final

【13】常用的断点调试快捷键：
蓝色拐弯箭头：一步一步的向下运行代码，不会走入任何方法中。
蓝色垂直箭头：一步一步的向下运行代码，不会走入系统类库的方法中，但会走入自定义的方法中。
红色垂直箭头：一步一步的向下运行代码，会走入系统类库的方法中，也会走入自定义的方法中。
蓝色向上箭头：跳出方法。
红色方块箭头：结束程序。
绿色右三角箭头：进入到下一个断点，如果没有下一个断点了，就直接运行到程序结束。
禁止断点：结束当前次未执行的断点。

调试的时候，在循环里增加条件判断。 具体操作：在断点处调出条件断点，可以在满足某个条件下，实施断点。
查看表达式的值。选择行，alt+f8

【14】面向过程和面向对象
面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，
以函数为最小单位，考虑怎么做。
面向对象：注重找“参与者”，将功能封装进对象，强调具备了功能的对象，以类/对象未最小单位，考虑谁来做。

面向过程–>面向对象，其实就是由执行者—>指挥者的一个过渡。

二者相辅相成，不是对立的，解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统；
具体到微观操作，仍然使用面向过程方式来处理。

【15】对象：具体的事物，具体的实体，具体的实例，模板下具体的产品。
类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板。
写代码的时候先创建类，再创建对应的实体。

【16】面向对象三个阶段：
面向对象分析OOA—Object Oriented Analysis
对象：张三，王五，朱六，你，我。
抽取出一个类—》人类

类里面有什么：
动词–》动态特性–》方法
名词–》静态特性–》属性

面向对象设计OOD—Object Oriented Design
先有类，再有对象
类：人类：peison
对象：zhangsna,lisi,zhuliu

面向对象编程OOP–Object Oriented Programing
属性：
属性用于定义该类或该类对象包含的数据或者说静态特征，属性作用范围是整个类体。
属性定义格式：
【修饰符】 属性类型 属性名=【默认值】；

方法：
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向
过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个
程序的基本单位是累，方法是属于类和对象的。

方法定义格式：
【修饰符】方法返回值类型 方法名（形参列表）{
//n条语句
}
void 代表没有返回值；
方法的作用：重用代码，封装功能，便于修改。

局部变量：放在方法中，需要初始值
成员变量：放在方法外

【17】创建类：
创建对象之后再开一个测试类。
new一个对象，开一个内存，用引用类型接收。 Person a=new Person();
第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次。
不同的对象，属性有自己特有的值，但是方法都是调用类中通用的方法。

【18】成员变量和局部变量
区别一：代码中位置不同
成员变量：类中方法外定义的变量
局部变量：方法中定义的变量，代码块中定义的变量

区别二：代码的作用范围
成员变量：当前类的很多方法
局部变量：当前的一个方法（当前代码块）

区别三：是否有默认值
成员变量：有
局部变量：没有。

区别四：是否要初始化
成员变量：不需要
局部变量：一定需要

区别五：内存中位置不同
成员变量：堆内存
局部变量：栈内存

区别六：作用时间不同
成员变量：当前对象从创建到销毁
局部变量：当前方法从开始执行到执行完毕。

【19】基本类型的默认值
booleam false
char "\u0000’(null)
byte (tyte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d
string null

【20】构造器
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象再堆中开辟空间
3.对对象进行属性的初始化动作。

new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显示的将构造器编写出来；
构造器的格式：
【修饰符】 构造器名字（）{

}

构造器和方法的区别：
1.没有方法的返回值类型。
2.方法体内部不能有return语句。
3，构造器的名字很特殊，必须跟类名一样。

注意：我们一般不会在空构造器中进行初始化，因为那样的话每个对象的属性就一样了。
实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写。

【21】构造器的重载
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2，一般我们会重载构造器，在重载的构造器中进行属性的赋值操作
3，在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错。
4.当形参名字和属性名字重名的时候，会出现就近原则：
在要表示的回想的属性前加上this.来修饰，因为this代表的就是你创建的那个对象。

【22】this
创建对象的过程：
在第一次遇到一个类的时候，对这个类进行加载，只加载一次。
创建对象，在堆中开辟空间。
对对象进行初始化操作，属性赋值都是默认的初始值。
new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值。

this指的是正在创建，当前调用的对象。

this关键字 用法：
1.this 可以修饰属性：当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生
就近原则，所以如果我要是直接使用变量名字的话，就指的是离的近的那个形参或局部变量，这时候如果我想要表示
属性的话，在前面加上：this.修饰。
如果不发生重名问题的话，实际上你要是访问属性也可以省略this。

2.this可以修饰方法：在同一个类中，方法可以互相调用，this.可以省略不写。
public void play(){
eat();
System.out.println("上网“}；
System.out.println("洗澡”）
public void eat(){
System.out.println("吃饭“}；

3.this 也可以修饰构造器：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行。

public Person (int age,String name,double height){
this(age,name)
this.height=height;
}
public Person(int age,String name){
this(age);
this.name=name;
public Person(int age){
this.age=age;
}

【23】static
1,static 可以修饰：属性，方法，代码块，内部类。布恩那个修饰构造器。

栈里存放局部变量，形参。
堆里存放对象，数组。
方法区里存放字节码信息，字符串常量池。

2.static修饰属性：
在类加载的时候，会将静态内容也加载到方法区的静态域中。
静态的内容先于对象存在。静态内容别所有该类的对象共享。
一般官方的推荐访问方式：可以通过类名.属性名的方式去访问。Test.sid=100;

3.static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块—》这种情况下，就可以用static修饰的属性。
属性： 静态属性（类变量） 非静态属性（实例变量）

4.static修饰方法。
static 和public 都是修饰符，并列的没有先后顺序，先写谁后下谁都行。
在静态方法中不饿能访问非静态属性，方法，不能使用this关键字。因为static的内容咸鱼对象存在。
非静态方法可以用对象名.方法名调用，静态方法除此之外还可以用类名.方法名调用（推荐）

【24】代码块的分类：普通块，构造块，静态块，同步块（多线程）
普通块：在方法中，限制了局部变量的作用范围。
构造块：在方法外写的代码需要加构造块。
静态块：static 修饰的构造块就是静态块。静态块中只能访问静态变量和静态方法。

总结：
1，代码块的执行顺序：
静态块最先执行，只在类加载的时候执行一次，（在类被加载的时候直接执行），所以一般以后实战写项目：
创建工厂，数据库的初始化信息都放入静态块。一般用于执行一些全局性的初始化操作。

在执行构造块，（不常用）
在执行构造器。（初始化操作）
再执行方法块中的普通块。

【25】包
1.包的作用：
为了解决重名问题（实际上包对应的就是盘符上的目录）
解决权限问题（不同包之间的访问权限）

2.创建包
包名定义:名字全部小写
中间用.隔开
一般都是公司域名到着写：com.jd com.msb
加上模块的名字 com.jd.login com.jd.register
不能使用系统中的关键字：nul ,con,com1----com9…
包声明的位置一般都在非注释性代码的第一行

3.导包
使用不同包下的类需要导包：import *..;例如：import java.util.Date;导包就是为了定位。
在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
同一个包下的类想使用不需要导包，可以直接使用
在java.lang 包下的类，可以直接使用无需导包：System.out.println(Math.random();
IDEA中导包快捷键：alt+enter;可以自己设置自动导包。
可以直接导入： /import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;/
import java.util.*; //*代表所有。

4.在Java中的导包没有包含和被包含的关系：
设置目录平级的格式（不是包含和被包含的显示）
import com.msb9.*;
import com.msb9.sub.D;

5.静态导入
import static java.lang.Math.*; //导入java.lang下的Math类中的所有静态的的内容。
System.out.println(random()）；//前面的Math.没写。
System.out.println(PI）；
System.out.println(round(5.6)）；
在静态导入后，同一个类中有相同方法的时候，会优先走自己定义的方法。

【26】封装
1，java中封装的理解：
将某些东西进行隐藏，然后提供相应的方式进行获取。
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、
封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？
封装把对象的多有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
适当的封装可以让程式码更容易理解和维护，也加强了程序吗的安全性。

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高程序的可扩展性、可维护性。
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.封装的好处。

3.上面的代码，对于属性age来说，加了修饰符private,这样外界对他的访问就受到了限制，现在还想加上其他的限制条件，
但是在属性本身身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加。
例：
public class Girl{
private int age;
private int duquAge(){
return age;
}
public void shezhiAge(int age){
if(age>-30){
this.age=10;
}
else{
this.age=age;
}
}
}
将属性私有化，被private修饰–》加入权限修饰符，一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
提供public修饰的方法让别人来访问/使用。
即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们再方法中可以加入限制条件。

4.实际开发中，方法一般会写成setter ,getter 方法：
可以利用IDEA中的快捷键生成：alt+insert—>getter and setter

0917
【27】继承
子类继承了父类，就可以直接用父类里的东西。继承提高了代码的复用性。
public class Student extends Person

需要注意的点：父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方法——
即setter，getter方法。

（1）继承关系：
父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围进行继承的
（2）继承的好处
1，提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上重复定义了
2.便于代码的扩展
3.为了以后多态的使用。是多态的前提。

（3）父类private修饰的内容，子类也继承过来了。
（4）一个父类可以有多个子类。
（5）一个子类只能有一个直接父类。但是可以间接的继承自其他类。

（6）继承具有传递性：
Student --》继承自Person—》继承自Object
Object 类是所有类的根基父类。所有的类都直接或间接的继承自ObJect.

【28】权限修饰符
同一个类 同一个包 子类 所有类
private *

default * *

protected* * *

public * * * *

default 默认的，一般不写，写了反而出错。

总结：
属性，方法：修饰符：四种：private ,缺省，protected,public
类：修饰符：两种：缺省，public

以后写代码
一般属性：用private修饰，方法：用public修饰。

【29】方法的重写
1，重写： 发生在子类和父类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写。
2.重写有严格的格式要求：子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。修饰符和返回值类型可以不同。

英文	位置		修饰符		返回值		方法名	参数	抛出异常	方法体

重载 overload 同一个类中 无关 无关 必须相同 必须不同 无关 不同
重写 override 子类父类中 父类的权限 父类的返回值 必须相同 必须相同 小于等于 不同
修饰符要低于 类型大于子类的
子类的

重写的修饰符：如果父类是pirvate,子类就应该是public，倒过来会出错。
重写的返回值类型：基本数据类型不同会出错，如果是引用数据类型，父类的返回类型是父类，子类的返回类型是对应的子类。

0918
【30】super修饰属性，方法
1.super指的是：父类的。
2.super可以修饰属性，可以修饰方法：

在子类的方法中，可以通过super.属性 super.方法 的方式，显示的去调用父类提供的属性，方法。在通常情况下，super.
可以省略不写；
System.out.println(super.age);
super.eat();

在特殊情况下，当子类和父类的属性重名时，你想要使用父类的属性，必须加上修饰符super，只能通过super.属性来调用。
在特殊情况下，当子类和父类的属性重名时，你想要使用父类的属性，必须加上修饰符super，只能通过super.属性来调用。
在这种情况下，super.就不可以省略不写。
eat();//子类的方法。
this.eat();//子类的方法。
super.eat();//父类的方法。

【31】super修饰构造器
其实我们平时写的空构造器的第一行都有：super（）—》作用：调用父类的空构造器，只是我们一般都省略不写。
所有构造器的第一行默认情况下都有super（），但是一旦你的构造器中显示的使用super调用了父类构造器，那么这个super（）
就不会给你默认分配了。如果构造器中没有显示的调用父类构造器的话，那么第一行都有super（），可以省略不写）
public Student (int age,String name,double score){
this.age=age;
this.name=name;
super.age=age;
super.name=name;
super(age,name);//利用super调用父类的构造器。 跟this（age,name)调用当前类的构造器很像。
this.score=score;

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super（）；
在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存：
因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行。

以后写代码构造器的生成可以直接使用IDEA提供的快捷键。

【32】object 类的tostring 方法
所有类都直接或间接的继承自object类，object类是所有Java类的根基类
也就意味着所有的Java对象都有object类的属性和方法。
如果在类的声明中未使用extends关键字指明其父类，则默认继承object类。

toString
public String toString()
返回该对象的字符串表示，通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应该是一个简明
但易于读懂的信息表达式。建议所有子类都重写此方法。
object 类的toString方法返回一个字符串，该字符串由类名（对象是该类的一个实例），at标记符“@”和此对象哈希码的无符号
十六进制表示组成。换句话说，该方法返回一个字符串，他的值等于：
getclass().getName()+"@"+Integer.toHexString(hashCode())
返回：该对象的字符串表达形式。

com.msb.test01.Student 全限定路径：报名+类名的完整表示
4554617c hasCode()—>将对象在堆中的地址进行哈希算法，返回一个码–》哈希码
将这个哈希码传入到integer.toHexString(哈希码）中，返回一个字符串，这个字符串是一个十六进制的书对应的字符串
对象–》堆中分配的地址–》进行了哈希操作–》哈希码–》转成十六进制–》String

现在，使用toString方法的时候，打印出来的东西“不好看”，对于其他人来说不友好，可读性不好。
我们现在是想知道对象的信息，名字，年龄，身高。。。。。。
现在的格式不好：
Student s=new Student(“feifei”,19,160.7)
System.out.println(s);
System.out.println(s.toString());

对toString()方法进行重写
public String toString(){
return “这是一个Student对象，这是对象的名字：“name+”,年龄：”+age+",身高;"+height;

总结：toString 的作用就是对对象进行“自我介绍”，一般子类对父类提供的toString都不满意，都要进行重写。
快捷键 alt+insert

【33】object 类的equals 方法
Phone p1=new Phone("huaweiP40,2035.98,2020);
Phone p2=new Phone("huaweip40,2035.98,2020);

System.out.println(p1p2);//对于引用数据类型来说，比较的是地址值。—》一定返回的是false.
boolean flag=p1.equals(p2);//点进源码发现：底层比较的是，比较的还是地址值。
System.out.println(flag);//返回值是false.

对equals方法进行重写：
public boolean queals(Object obj)

//将obj转为phone类型：因为obj接受的实参是p2,p2不是object类型的。
Phone other=（Phone)obj;
if（this.getBrand()==other.getBrand()&&this.getPrice()==other.getPrice()&&this.getYear()==other.getPrice())
return true;
else
return false;

0921
a instanceof b; 判断a对象是否是b这个类的实例，如果是 返回true，如果不是 返回 false

【34】类和类可以产生关系：1.将一个类作为另一个类中的方法的形参。2.将一个类作为另一个类的属性。调用时要new.

【35】多态-副本
多态跟属性无关，多态指的是方法的多态，而不是属性的多态。
Cat c=new Cat();
Dog d=new Dog();
Pig p=new Pig();
Animal an=p/c/d;
g.play(an);

总结：1.先有父类，再有子类：—》继承 现有子类，再抽取父类—》泛化
2多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。
多态指的就是同一个方法的调用，然后由于对象不同会产生不同的行为。

多态的好处：
为了提高多种状态，符合面向对象的设计原则：开闭原则。
开闭原则：指的是扩展是开放的，修改是关闭的。
注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习反射。

多态的要素：
一：继承：Cat extends Animal,Pig extends Animal,Dog extends Animal
二：重写：子类对父类的方法shout()重写
三：父类引用指向子类对象；

1.Pig p=new Pig();
2.Animal an=p;
将上面的代码合为一句话：
Animal an=new Pig();
=左侧：编译器的类型
=右侧：运行期的类型

public void play(Animal an){//Animal an=an=new Pig();
an.shout();
}
父类当方法的形参，然后传入的时具体的子类的对象，然后调用同一个方法，
根据传入的子类的不同展现出来的效果也不同，构成了多态。

【36】向上转型，向下转型。

【37】工厂模式：
不仅可以使用父类做方法的形参，还可以使用父类做方法的返回值类型，真实返回的对象可以是该类的任意一个子类对象。
简单工厂的实现，
简单工厂模式的实现，他是解决大量对象创建问题的一个解决方案，将创建和使用分开，工厂负责创建，使用者直接调用即可。简单工厂模式的
基本要求是
定义一个static 方法，通过类名直接调用。
返回值类型是父类类型，返回的可以是其任意子类类型
传入一个字符串类型的参数，工厂根据参数创建对应的子类产品。

【38】final修饰符
final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗成的规定：名字大写。
final修饰基本数据类型，不可以修改值。
final修饰引用数据类型，那么地址值就不可以改变，对象的属性依然可以改变。
引用形参d被final修饰，指向不可以改变。
final修饰方法，那么这个方法不可以被该类的子类重写。
final修饰类，代表没有子类，该类不可以被继承。
一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了。

JDK提供的Math类：看源码发现：
1.使用Math类的事后无需导包，直接使用即可：
package java.lang;

2,Math类没有子类，不能被其他类继承了
public final class Math

3.里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写的
原因：子类没有必要进行重写。

4.外界不可以创建对象。
Math m=new Math();错误。 因为 Math的构造器被final修饰。

5.发现Math类中的所有的属性，方法都被static修饰
那么不用创建对象去调用，只能通过类名.属性名 类名.方法名 去调用。

【39】抽象类，抽象方法
1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写。