JAVAoop--0基础（有jdk的安装教程）

软件的安装

java开发目前主流的工具有eclipse，myeclipse，idea等，但是官方推荐的是eclipse，所以我们前期选择使用eclipse，后期采用idea。
网盘链接：https://pan.baidu.com/s/10kka1vjTbZV_IbCioIFrjg
复制这段内容后打开百度网盘手机App，操作更方便哦
提取码：biaw
eclipse简介：
①eclipse解压安装即可用
②eclipse的使用
概念：
工作空间（workspace）：里面可以存储多个项目
项目（project）：一个项目
eclipse界面简介：
上侧工具栏，中央是工作区，其他的选项卡即view（视图）
打开选项卡：window->showview->other->搜索选项卡->确认
选择视角：右侧open perspective（打开所有视角），选择需要的视角。
切换工作空间：file->switch workspace->other 输入工作空间
eclipse开发java项目：
1）新建java项目：file->new->other 选择所要创建的项目
2）java项目文件结构：
①jre：每一个项目中都必须有自己的jre
②src：资源文件夹，存放.java源文件
③bin：用来存储编译后的文件（.class）
3）更改项目文件结构：
右键项目——>properties->java build path（java构建路径）
第一个选项卡：资源目录（src）和bin（二进制目录）
第三个选项卡：更改jre（jdk）
4）创建java源代码文件，编译运行：
编译：编写好.java文件就自动保存
运行：右键.java文件->run as->java application

jdk的安装以及环境配置

概念：
jdk是java（J2SE）开发环境，包含解析器、jre（java运行环境），以及其他工具。
安装：
1.获取jdk安装包，然后解压获得java主目录
解析包里主要文件有bin和jre：
①bin目录里面是存放二进制命令文件，其中主要文件有：
java：可以用来测试版本
javac：将源码文件转化为电脑可识别的文件（.class）
jar：将.class文件打包，便于运输和管理
②jre目录：java运行时环境（包含jvm）
2.配置环境变量
未配置环境变量时：
注意：我这里是因为原来有一个版本的jdk，可以忽略。
右键计算机->属性->高级设置->环境变量->path（系统环境变量中的path）后追加java主目录/bin（path主要做用是快速访问）
配置完成：

3.测试
在一个文件夹下新建一个文本文档Test01，并输入代码，将文件后缀改为.java：

打开控制台，进入文件路径，然后输入javac Test01.java:

可以观察到源文件夹，多了一个Test01.class的文件，然后在控制台继续输入 java Test01：

输出hello，world！则成功调试。
注意：测试过程中，如果出现GBK字符不能转译，则将原来的文本文件另存为ANSI格式，然后再编译。

java变量与应用

变量
概念：变量是可以不断改变的存储量。
变量与常量命名规范：
变量内容由数字，字母，下划线，$，中文等。
变量第一个内容不能以数字开头。
如：
byte 1a//不合法
byte _ss//合法
变量名不能是关键字
如：
int byte=10；//不合法
定义变量：（变量名存放在栈空间 stack）类型 名称；变量必须在申明后才能使用
使用变量：
①赋值（无限次赋值）
变量名=值（这个值存放在常量区）
②取值（根据变量名取值）
int a=10；
a=a+10；
数据类型
不同的数据类型分配不同大小栈空间
二进制：每一个0 1码，表示一个二进制位数
字节：八位二进制就是一个字节；
字符：
常见的基本数据类型有八种：
整数型（4种）：
byte：1个字节（范围-128——127）-2^7——27-1
short：2个字节（-2^15——215-1）
int：4个字节（-2^31——231-1）
long：8字节（-2^63——263-1）
浮点型（2种）：
float：单精度 4个字节
float 变量名=小数f（f表示单精度类型小数，如果不加则默认小数为doule类型）； 如：float a=1.5f；
double：双精度 8个字节
boolean：值只有true或者false。如：Boolean b=15>10 值为true。
char：两个字节，值用单引号‘’；A—Z：65-90；a-z：97-122
例如：char ch=‘a’;int i=ch;System.out.println(i);//输出a=97
数字类型转换规则：
小转大，直接转：byte a=10；short b=a；
大转小，强制类型转化：int a=10；short b=（short）a；（直接赋值会报错，不能直接大专小）
运算过程中整数运算默认为int类型，小数默认为double类型。如果定义不同的类型，进行运算则选大类型。
常量（一次定义一次赋值）
语法：final 如：final byte b=28；b=12；会报错，不能进行再次赋值
输入（input）与输出（output）
概念：
程序接受的信息叫输入，程序显示的信息叫输出。
输出：
System.out.println();//打印完后换一行
System.out.print()；//只打印不换行
System.err.println()；//红色打印 换行
转义符号：标志
\n 新起一行
\t 制表对齐
输入：
创建输入工具实例：
Scanner input=new Scanner(System.in);//复杂的变量都是存放在堆中，需要new
接受输入信息：
类型 变量名=input.next类型();
如：
byte age=input.nextByte();//接收Byte

java运算符
单目运算符：++、- -
双目运算符：+、-、、/、%（目指操作数）
%求余数
++ - -
a++:先用后加1
++a：先加1后用 如：int a1=10;int b1=(a1++)+(++a1)+(a1++);结果为34.
a- -：先用后减
- -a：先减后用
注意：如果++或者- -是单独一行，则直接执行自加或自减
赋值运算符
+=、-=、=、/=、%=：先运算后强转赋值
如：short ss=6;
ss=ss+6//报错，因为没有强转，6是int类型。
ss+=5;//+=除了进行运算还能进行强转
逻辑运算符
语法：逻辑表示1 逻辑运算符 逻辑表达式2
&逻辑与：两个逻辑表达式都必须执行
|逻辑或：两个逻辑表达式都必须执行，只要有一个为真就为真
&&短路与：如果第一个表达式为false，则第二个不会执行
||短路或：如果第一个表达式为true，则不会执行第二个
如：int ii=3;
int nn=3;
boolean b0=ii++>5&ii++<4;//两个表达式都执行
boolean bb1=nn++>2&&nn++<2;//如果第一个为false则不执行第二个
条件运算符
>=,<=,==,!=
取反：！逻辑表达式
如：boolean b=！（10>5） //结果为false
三元运算符
语法：
逻辑表达式？表达式1：表达式2
如：int ll=5;
int cc1=10;
int min=ll>cc1?ll:cc1;//求两个中哪个大用>,哪个小用<.
如果逻辑表达式为true则执行表达式1，反之执行表达式2。
运算符优先级
=优先级最高，（）优先级最高，单目高于双目高于三目

选择与循环

概念
根据多种条件选择不同分支
代码块：多行代码
if else 选择结构
语法：标准if else
if(条件表达式1){
满足条件1
}
else if{
不满足条件1且满足条件2
}
else if（表达式n）{
…
}else{
…都不满足
}
第一种改写：if（）
第二种改写：if，else if，…else 每个语句中只有一个语句
第三种改写：if（）esle（）
第四种该写：if() else if()
switch case 选择结构
if else 条件判断，满足条件，执行分支的代码块
switch case 等值判断
switch(变量){
case 值1：
case 值2：
case 值3：
default：（默认值，所有case不满足则进入case）
}
小节：
switch case，将变量的值和每一个case比较，如果相等就进入该case，如果不等就匹配下一个case
如果所有case都没匹配上，则进入default。
如果匹配到的case没有break，则执行该case下的所有case，包括default。
如果default不在代码最后且没有break，也会执行下一个case。
case的值必须是常量，类型是char，byte，short，int。jdk7后增加string，enum（枚举）。
循环
概念
循环：重复n次执行的操作，重复次数和重复操作
标准for循环：
for（初始表达式；逻辑表达式；表达式3）{
}
初始表达式：所有循环开始前执行的代码，只执行一次
逻辑表达式：控制循环次数，每次循环前执行
表达式3：每次执行完该次循环后需要执行的代码。（即循环体内的表达式执行完）
while循环
while（条件表达式）{//条件表达式控制次数
重复次数
}
do while循环
语法：
do{//不管条件成不成立，都要执行一次重复操作
}while（条件表达式）；//第n-1次执行前操作
如：
int a=0;
do {
System.out.println(“第”+a+“次打印”);
}while(a++<10);//执行次数是0到10.
break与continue关键字
break：终止整个循环；
continue：终止本次循环。//continue后的代码都不执行
如：
int sum=0;
for(int i=1;i<=100;i++) {
if((i+1)%2==0) {
continue;
}
sum+=i;
}
System.out.println(“偶数和为：”+sum);
嵌套循环
语法：
for（）{//外层循环
for（）{
内
}
}

数组

数组
概念
数组：一个可以定义多个同类数的类型，再内存（堆空间）中是连续的一段地址空间
定长、连续的一组数据（不可变）。
定义数组
语法：
第一种：类型[] 数组名
如：String name[]= {“tom”,“anna”,“lisa”};
第二种：类型 数组名[]
如：int[] sorce= {11,22,33,44};
初始化数组
第一种：只申请空间，每一个成员都是默认值
类型[] 数组名=new 类型[长度];
样例：
//申请了10个short长度的空间，每个成员为0
short[] ages=new short[10];
//每个成员的默认值为false
boolean[] b=new boolean[3]
//每个成员的默认值为null
String[] s=new String[3]
第二种：
类型[] 数组名=new 类型[]{成员1，成员2…}
样例：long[] l=new long[] {1,2,3,4};
第三种：
类型[] 数组名={成员1，成员2…}
样例：short[] s= {1,2,3,4};
小节：
同一个数组变量，第二次初始化时不能使用第三种类型
样例：
byte[] age=new byte[10];
age=new byte[20];//第二次初始化
age=new byte[] {1,2,3,4,5};
age= {1,3,5,6};//会报错。重新申请空间，必须初始化空间new 类型[]
使用数组
数组设置成员：
语法：数组名称[下标]=值；
获取数组成员（下标）：
数组名[下标]
循环操作数组：
标准for循环：
byte[] age=new byte[10];
for(int i=0;i<age.length;i++) {
byte a=age[i];
System.out.println(“第”+i+“个：”+a);
}
增强for循环：
for（类型 别名：数组名）
样例：
for(byte b:age) {//可以即快速操作数组，但是无法看到下标
System.out.println(b);
}
数组工具
jdk自带的用于操作数组的快捷工具
两个数组对比：Arrays.equals（数组a，数组b）。两个数组长度相同，并且每个下标对应的值相同，才是相同数组
样例：
int[] a= {1,2,3,4,5};
int[] b= {1,2,4,3,5};
int[] c= {1,2,3,4,5};
int[] d= {1,2,3};
boolean flag=Arrays.equals(a,c);
System.out.println(flag);
排序（升序）：
Arrays.sort(数组名)；
样例：
Arrays.sort(b);
for(int i=0;i<b.length;i++) {
System.out.println(b[i]);
}
填充：
Arrays.fill（数组名，初始值）：统一设置成某个值
样例：
Arrays.fill(a, 9);
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
数组复制：
Arrays.copyof(数组，新数组长度)
样例： int[] b=Arrays.copyOf(a, 5);
tostring：将数组的所有成员转化成字符串：[成员1，成员2…]。
Arrays.tostring(数组)；
样例：String a=Arrays.toString(a);//可以快速查看数组的成员
System.out.println(a)；//数组需要循环输出，转成字符串直接输出
binarysearch：
Arrays.binarysearch(数组，被查找的数据)：查找对应数组的下标（采用二叉查找）
数据必须时升序排好
数组中有被查找的数据，返回对应的下标
样例：
int[] a= {1,2,3,4,5,6,7};
int b=Arrays.binarySearch(a, 4);
System.out.println(b);//输出结果为3
如果找不到：①返回为负数②找第一个比被查找大的数③下标从1开始
样例：
int[] a= {1,2,3,5,6,7};
int b=Arrays.binarySearch(a, 4);
System.out.println(b);//输出结果为-4。
//如果被查找的值比数组中最大的值都大，则返回最大的位置。（查找的理念为二叉树）
字符串
概念：有多个字符构成的一个值即为字符串。
字符串定义与初始化：
定义：String 变量名；
初始化或赋值：
String a=“张三”;
String a=new String(“张三”)
字符串操作：
只能进行+操作，任何类型和string相加都变成一个string
样例1：int a=5；
string b=“a”+a//输出a5
样例2：
String a=“Hello”+“world”;
for(int i=0;i<a.length();i++)
{
System.out.print(a.charAt(i));//chart(下标)：获取对应字符串下标字符
}
二维数组
概念：一维数组的每一个成员也是一个一维数组，该数组为二维数组
定二维数组：
第一种：类型[][] 数组名;
第二种：类型 数组名[][];
初始化二维数组：
第一种：指定了一维数组、二维数据统一的长度
类型[][] 数组名=new 类型[一维长度][二维长度]
第二种：只指定以为数组的长度
类型[][] 数组名=new 类型[一维长度][]

类与对象

概念
类：（抽象）具有相同特征数据的集合，或者相同特征对象的抽象叫做类，如生产的模具
如：人类，猫类，汽车类，飞机类等等
对象：（具体的）类的一个实例即为一个对象。
如：张三，白猫，别克川aXXXX(用数据具体描述出来)
类的构成：类名，属性（静态特征），方法（动作行为）
如：
学生类{
//属性
学号，性别，年龄，所在班级 所在年级
//方法
考试（）
上课（）
}
定义类的步骤
类的构成：
class 类名{
//成员变量1（属性，即具体对象的属性）
//成员变量2
//成员方法（具体对象的行为）
//局部变量（只作用于当前代码块，调用一次执行一次，不能前面加static）
//成员代码块
//静态方法（所有成员都有的，一模一样的行为；在类创建的时候静态方法就加载）
//静态变量（成员变量前加上static修饰词；不能放在代码块中）
//静态代码块
//构造方法（）
}
样例：
class 鞋{
尺码
颜色
价格
品牌
穿（）
走路（）
}
定义类步骤：
定义类名（发现类）
定义类的属性（大部分都是成员变量）
定义类的方法
创建类的一个对象（实例）：
定义一个对象：
类型 对象；
初始化一个对象：
对象=new 类型
方法
概念：可以重复调用（通过名称）的代码块{} //用什么类型的类型名取决与你要返回的是什么类型的数值
语法：
修饰符 [static] void 方法名（参数列表）{
方法体
}
方法名：调用的唯一关键字，只能通过方法名调用
参数列表：为方法体服务，调用该方法时必须全部满足（参数列表中的即为局部变量）
方法体：重复调用的代码块
返回值：
最后一行逻辑代码；该行代码后无可执行代码
如果方法体中没有return，表示没有返回值，则类型必须为void（注意：构造函数没有返回值）
方法的返回值在方法体执行完之后返回给调用者（return返回的数据，不能直接读取，需要先设置一个接收数据）
方法体中return的类型必须和方法规格（类型名）中的返回值类型一致
样例：
Person类
int laught(String age,String gender) {//定义一个方法；参数列表可以多个，用逗号隔开
System.out.println(age+gender+name+“在哈哈大笑”+(++count)+“次”);//成员方法可以调用成员变量
return count;//无返回值用void，有返回值用int
Person调用
p1.laught(“24岁”,“男”);//对象调用成员方法;如果调用的成员方法有参数列表，则在调用的时候把参数列表的值填充
p1.laught(“24岁”,“男”);
int cnt=p1.laught(“24岁”,“男”);//这里使用的调用者（p1.laught(“24岁”,“男”)）相当于count
void没有返回值
参数列表和成员变量的区别：
成员变量一般是一个对象里不易改变的的信息，如姓名，年龄等。
参数列表一般是一个对象里需要改变的，如乘坐的交通工具
简写：
void 方法名（）{//{}方法体
可重复调用的代码块
}
在java中常见的三种方法：成员方法（要有对象才能实现），类方法，构造方法
成员方法：必须通过对象调用，该方法属于成员
调用：对象.方法（参数列表）
类方法（静态方法）：
该方法归属于类，可以通类名或对象名同时调用，方法前必须有stati关键字。类方法不能调用成员变量。
调用：
类名.方法（参数列表）
或
对象.方法（参数列表）
构造方法：（主要针对成员变量）
语法：
修饰符 类名（参数列表）{方法体} 注:方法名是类名，没有返回值
构造方法的作用:创建一个对象(主要是初始化成员变量)
new 构造方法名（参数列表）；//构造方法即为类名
对象必须都是new出来的（通过构造方法），每一个类至少有一个构造方法，如果类（class）中
没有自定义构造方法，程序就会默认增加一个无参的构造方法。
例如：
class Person{
Person（）{}
}
构造方法通过new构造方法直接调用
样例：
类：
Person(){
System.out.println("***************");
}
调用：
Person p1=new Person()//运行可直接输出：***************
变量
成员变量：对象的变量（成员变量也可以不给值，默认有初始值）
静态变量：
语法：变量前static关键字，只能在成员变量前加关键字，可以通过类名直接访问
静态变量可以不给初始值，有默认值
使用方法：
类名.静态变量
对象.静态变量
局部变量：在代码块中定义的变量（{}）
语法：和成员变量相同（但是不能加static）
使用方式：
使用前必须初始化赋值，不给值会报错
局部变量有生命周期（有效期），有效期的范围是代码块里面
局部变量名称可以和成员变量名称相同，优先使用局部变量的值
样例：
String name=“张三”
System.out.println(name);//访问局部变量
System.out.println(this.name);//访问成员变量

this关键字（当前对象）
this.成员变量
this.成员方法
样例：
public void dog()
{
//访问成员变量（如果没有与局部变量同名可以省略this）
System.out.println(this.gender+name);
//访问成员方法
this.speak();（speak的方法：public void speak()）
//访问静态方法(成员方法可以访问静态，静态不可以访问成员)
this.cat();（cat的方法：public static void cat()）
}
this()：调用本对象的构造方法，只能出现在构造方法中，调用另一个构造方法，且必须加在第一行
第一种：this（）->无参的构造方法
样例：
public Person(String name) {//带参构造方法
this();//this（）只用于构造方法中，调用另一个（重载）构造方法
}
第二种：this(name)->带参的构造方法
样例：
public Person(String name,String gender)
{
this(name);//调用带参的构造方法
this.gender=gender;
}
构造方法

修饰符
概念：限制访问范围，即作用域
修饰符出现的位置：
①类：修饰符 class 类
②成员变量：修饰符 类型 成员变量
③成员方法（类方法）：修饰符 [static] 返回值 方法名（参数列表）
④构造方法：修饰符 类名（参数列表）
修饰符的值：
private（私有）<default（默认）<protected(保护)<public(公有)//没有修饰符默认为default
private（私有）:在同一个类中可以使用
default（默认）:在同一个包中可以使用
protected：在子类中可以使用
public：其他地方
包（package）
包是一种文件管理规范，类似于d盘下面的文件夹
包：域名（一级包名）.项目名.分类
如：cn.sina.bbs.utils//新浪的bbs项目下的工具包
使用包：不同包之间相互引用，需要在class上引用
只有两个文件相互作用，且都在一个包下才不需要import
代码块
成员代码块
语法：{}
只执行一次，创建对象时最后执行
静态代码块//初始化数据的作用，不能直接调用
语法：static{}
创建类的时候最后执行
方法扩展知识
方法参数使用
传值：值拷贝
当方法的参数为8大基本类型或者string类型时，方法中的形参都是一个原值的拷贝
示例：
类中：
double PI=3.14;
public void cycle(double r)
}
double s=PIrr;
System.out.println(s);
}
程序中：
int a=10;
p1.cycle(a);//将a的值拷贝给r
System.out.println(a);//输出还是10
传址：址传递
当参数为复杂类型，（除8+string类型外）
方法重载（overload）
概念：同一个类中，方法名相同的多个方法，必须符合重载的要求
简化了类调用方法的代码
条件：
同一个文件（同一个类）
方法名相同
参数列表不同（参数相同是参数列表能一一对应，有一个不能对应就不是相同）
和修饰符和返回类型无关
样例：
//重载
public void max(int a,int b)
{
System.out.println(a>b?a:b);
}
//重载参数列表
public void max(double a,double b)
{
System.out.println(a>b?a:b);
}

继承与多态

继承
概念
B类可以继承A类的信息，B类信息=A类信息+B类独有信息
两个类，一个类可以通过extends关键字获取另一个类的属性和方法（受修饰符限制），这种关系即是继承
继承步骤：
定义父类（被继承的即为父类），父类中主要是公共属性和公共方法
定义子类（继承父类的类），子类中有自己独有的属性和方法
通过extends实现继承关系，子类只能继承一个父类（不支持多继承）
继承要点：
子类中能够访问父类中protected、public属性和方法
子类不继承父类的构造方法（和构造方法的修饰符无关），但是可以通过super关键字调用
子类独有的方法，如果和父类的方法名相同，且参数列表相同叫重写
子类对象可以通过super关键字来访问父类对象的信息
继承实现（extends)（父类私有的成员变量和成员方法不能继承；子类的继承权限来自父类的修饰词）
当对象调用继承中的方法时，先创建父类对象再创建子类对象
样例：
public mankind() {
System.out.println(“正在创建父类对象”);
}
public student() {
System.out.println(“正在创建子类对象”);
}
new student();//输出"正在创建父类对象"“正在创建子类对象”
人员类（mankind）：
public class mankind {
private String name;
private String gender;
private String birthday;}
学生类(student)：
public class student extends mankind {
private String stuID;
private String classID;}
教师类(teacher)：
public class teacher extends mankind{
private String job;
private String tno;
}
super关键字（调用父类的成员变量或成员方法）
super.父类对象成员变量
this.父类对象成员变量（先找当前类有此成员变量没有，有就指向当前类，没有就指向父类）
super.父类对象成员方法
super（参数列表）//父类构造方法
子类中构造方法第一行代码必须是调用父类的构造方法语句，如果没有则默认增加super（）
子类的所有构造方法都可以调用父类的构造方法，但是受修饰符的限制
object类
概念
object是所有复杂类型（不包括8大基本类型）的最高父类
class A（） //A的父类即object
object的方法
tostring（）方法：复杂类型一般都不相等，除非两个是s1=s2
返回对象信息，以字符串的方式，默认格式，全限定名@hashcode码
Student s1=new Student（）；
String Str=s1.toString（）；
System.out.println(s1);//会默认调用toString的方法，与System.out.println(Str)
输出结果一致：cn.kgc.Class.Create.student@1b6d3586
equals（）方法：
如果用对比，比较的是地址；equals（）比较的是内容
如果不重写还是，所以一般都要重写，复杂类型的对比，如果用==，则比较的是tostring
hashcode（）方法：哈希码：访问的是对象的地址
默认：等同于对象的内存地址
小节：
如果没有重写复杂类型的tostring，则调用object的tostring全限定@hashcode码
如果两个对象==来判断，实际上调用tostring（）sostring（）
ab//a.toString（）==b.toString（）理论上是不可能永远相等，除非a，d是一个对象
复杂类型需要用equals比较，但也需要重写，不重写也是全等
注意：直接定义的字符串string，如果调用equals则直接调用object类的，比内容
和类中的用法不一样，需要注意。
继承中的特殊知识点
构造方法
参考super的三种使用
方法的重写（overridding）：重写之后对象只有子类方法，父类方法被覆盖
父子类中，子类的方法可能存在重写
子类与父类方法名相同
参数列表必须相同
返回值类型相同
修饰符的范围不能小于父类修饰符的范围

修饰符
同类 同包 同子类 其他
private(私有) √ × × ×
default（默认） √ √ × ×
protected（受保护） √ √ √ ×
public（共有） √ √ √ √
多态
概念（多态使用的基础是继承）
同一个数据多种状态展现方式
结论：
子类可以看成父类类型，语法以父类为主，实际上是调用的子类方法（所以会受到修饰符的限制）
转型
同一个数据多种状态之间的转换
向上转型：子类转父类，自动转型
向下转型：父类转子类，强转
如：
student s1=new student()
uers u=new uers()
uers u1=new student()//向上转型
student stu1=(student)u1//向下转型
student stu2=(student)u//类型转换错误，向下转的前提是要有向上转
多态的应用
方法 参数的多态
方法 返回值的多态
方法的返回值的类型是父类
public static User Create(int num){//user为父类，teacher和student为子类
if(num==1){
return new teacher();//返回值，自动转化为父类型
}else{
return new student();//返回值，自动转化为父类型
}
}
instanceof 判断
作用：判断一个对象是不是符合某一个类（对象是不是属于这个类，子对象属于父类），返回值是boolean类型
student s=new student
boole a= s instanceof student//返回true
final 关键字
概念
final：最终，不可改变
final在类上使用：最终类不可被继承
final在变量上使用：该变量不可再被改变，final类型的常量必须给初始值
final在方法上使用：该方法不可被重写
小节：父类出现final方法（不管static还是成员）子类都不能出现重写方法。

抽象类与接口

抽象类
概念：是一个不需要创建实例（抽象）的类，同时该类中存在一些方法，所有子类都会完全重写
抽象类特点
class 有abstract关键字，该类无法被实例化
结构上多了抽象方法（相对于普通结构），抽象方法没有方法体
抽象类被继承后结论：
抽象类中可以有普通方法，但是抽象方法不能有方法体
抽象类被抽象类继承，抽象方法可以被重写也可以不重写
抽象类被普通方法继承，则必须重写，否则会报错
抽象类结构
修饰符 abstract class 类名{
构造方法
成员变量
成员方法
成员代码块
静态变量
静态方法
静态代码块
抽象方法//抽象类独有
}
抽象方法：
概念：没有方法体的方法。只有抽象类和接口才有抽象方法
语法： abstract 返回类型 方法名（）
样例：public abstract void print();
接口
概念
接口：即一种标准或者一种规定
定义接口
//接口里没有构造方法
修饰符 interface 接口名{
public static final 类型 变量名//静态常量（即便没有写public、static、final还是默认会有）
public abstract 返回类型 方法名（参数列表）；//抽象方法
public static 返回类型 方法名（参数列表）//静态方法
接口继承
子接口可以继承父接口
可以继承多个父接口
public interface Use3 extends Usb2,Usb1
接口实现(类实现接口 implements)
类实现接口，用implements关键字，可以实现多个接口
普通类实现父接口，必须重写父接口中的抽象方法
抽象子类实现父接口，可以不重写父接口中的抽象方法
面向接口编程（iop）
多定义接口，选择抽象类和接口类作为父，优先接口，组合
使用具有接口特征的子类对象时，建议使用接口类型
形参udisk类型，建议写成接口类型
public void print(Usb usb) {//解耦设计，面向对象编程
usb.usbIn();//调用插入的方法
usb.usbOut();//调用退出的方法
}
public void print(udisk u) {//耦合设计
usb.usbIn();//调用插入的方法
usb.usbOut();//调用退出的方法
}
抽象类与接口的区别
接口区别：
抽象类使用abstract关键字，接口用interface关键字
使用区别：
抽象类中的抽象方法没有方法体，子类继承抽象类必须重写抽象方法
接口在使用的时候要使用关键字implements，同时接口可以多继承
接口中成员变量是默认为static和finally
成员方法只有静态和抽象
其他知识
时间
语法：System.currentTimeMillis()
返回的是：long 类型，单位毫秒，值1970-1-1之间的时间差
样例：
long starttime=System.currentTimeMillis();//记录开始时间
System.out.println(“输入一句话显示你用的时间：”);
String Speak=input.next();
long endtime=System.currentTimeMillis();//记录结束时间，单位是毫秒
int i=(int)(endtime-starttime)/1000;//记录结束时间
System.out.println(“你用的时间是：”+i+“秒”);
随机整数（0-n）
类:java.unit.Random;
语法：随即对象.nextXXX（极限值）
样例：
创建工具对象
利用工具对象的nextXXX(n) 方法随机0-n随机整数
Random ran=new Random();//创建一个随机对象
for(int i=0;i<10;i++) {
int b=ran.nextInt(9);//给随机数的范围为9
System.out.println(b);
}
字符串（线程安全 StringBuffer）
创建字符缓冲对象 StringBuffer
增加内容 append（“内容”）
获取字符串的方法是toString
StringBuffer sb=new StringBuffer(">");//创建一个字符缓冲对象，并给初值<
sb.append(">");
sb.append(">");
sb.append(">");
String s=sb.toString();//用tostring接收字符串
System.out.println(sb);//输出字符串>>>>
关闭jvm虚拟机（程序强制退出）
语法：System.exit(数字状态码)
0：表示正常结束
其他数字：表示非正常结束
for(int i=0;i<10;i++) {
if(i>5) {
System.exit(1);//程序退出，关闭虚拟机
}
System.out.println(i);//打印i
}
System.out.println(“谢谢使用”);//这行代码不会执行

异常

概念：引起程序非正常结束的原因
如：常见的除数样例
int a=10;
int b=0;
int c;
c=a/b;
System.out.println©;
java的异常处理主要有两大类：
error：非jvm引起并处理的异常，如设备断电导致的异常
exception：jvm能够自己处理的异常，主要由异常对象来完成
java的异常处理：catch，try，finally，throws，throw
java异常机制：不破坏原有结构继承上
异常常用术语
try块：可疑代码块，可能产生异常的代码块
try块主要放的是可能产生异常的代码块，如果产生异常，我们才能在后续处理（如catch）
如果程序处理了，就会继续执行
try知识点：
try不能单独存在，要和其他关键字（catch、finally）一起使用
try块中出现return关键字，那么程序可能提前结束（没有异常）
catch：捕获
catch处理相邻try块中的异常
catch知识点：
必须和try块配套使用
一个try块可以匹配多个catch块
多个catch块，如果有父子关系，子异常在前，父异常在后
如果出现了return关键字，catch块所在方法直接结束
如果catch块中出现System.exit(0),jvm直接关闭
finally（最终代码块）
finally块：只要是try块产生异常，不管catch有没有捕获到异常，finally块都会最终执行一次
finally不能处理异常（catch可以处理异常）
finally不能单独使用
在try或catch中出现return关键字，finally不受影响（但是同方法中后续代码不会继续执行）
在try或catch中没出现return关键字，finally不受影响（但是同方法中后续代码会继续执行）
在try或catch中出现System.exit（0）时，finally才不会执行
注意执行顺序：try->catch->finally->return
throws（抛出异常）：有抛出异常等待处理
位置：出现在方法上，参数列表之后
作用：严格要求参数调用者处理异常
如：public static void test() throws Exception
throw：人为手动抛出一个异常
throw new 异常类型（异常详细信息）
throw和throws配套使用
public void setage(bety age) throws Exception{//将这个异常抛给上一级处理
if(age<0){
throw new Exception(“年龄小于0)；//人为手动抛出一个异常
}else{
this.age=age
}
}
组合：
try{
}
catch（InputMismatchException i）{}
catch（ArithmeticException a）{}//catch可以有多个，可以让不同的异常进入不同的代码块
try中发现异常的行数之后，会直接执行catch代码块。异常之后的代码块不会执行，而且try之外的异常不能捕获
InputMismatchException：输入类型不匹配
ArithmeticException：算术异常
异常对象
常见的异常对象->RuntimeException->Exception->Throwable
Throwable提供两个方法
getMessage()：String->返回的是异常详细信息
a.printStackTrace()：红色打印异常对象所有信息
常见异常：
RuntimeException：运行时异常，是Exception的子类
ArithmeticException：算出异常，如除数为0
InputMismatchException：输入类型不匹配
java.lang.NullPointerException：空指针异常（空地址）
String str=null;
System.out.println(str.length());
java.lang.ArrayIndexOutOfBoundsException：数组下标越界异常
java.lang.ClassCastException：类型转换错误