JAVA编程基础知识

SHI匕

已于 2023-06-23 21:27:05 修改

阅读量501

点赞数 2

分类专栏： JAVA 文章标签： java 开发语言算法

于 2023-04-09 19:40:49 首次发布

本文链接：https://blog.csdn.net/qq_63161641/article/details/129969084

版权

JAVA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

常量

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性
常量的命名规范：
单个单词：全部大写
多个单词：全部大写，单词之间用下划线隔开

标识符与关键字

标识符

用来标识类名，变量名，方法名，类型名，数组名及文件名的有效字符序列，即名字
（1）标识符有字母,数字，下划线，美元符号（$）组成，长度不受限制
（2）第一个字符不能是数字
（3）标识符不能是关键字
（4）标识符不能是true,false,null。

起名的软性建议

方法和变量：
当标识符是一个单词时，全部小写。例：name
当标识符是多个单词时，第一个单词首字母小写，其他单词首字母大写。例：firstName
类名：
一个单词：首字母大写。例：Name
多个单词时：每个字母首字母大写。例：FirstName

关键字

具有特定用途或被赋予特定意义的一些单词

boolean byte short long int float double char(数据类型)
break （循环中执行了break语句，那么整个循环语句结束）
continue（循环中执行了continue语句，则本次循环结束，进入下一次循环）
class enum interface（引用数据类型）
case default do else if for switch while(用于条件和循环语句)
import（）
new（）
package（包）
private （权限修饰符）
public（）
return（方法中用来返回数据）
static
void

数据类型

1.基本数据类型

  数据值是存储在自己的空间中，赋值给其他变量，也是赋的真实值
   精度从低到高：byte<short<char<int<long<float<double

(1)数值型

整数型：byte,int,short,long；浮点型：float,double

byte:1字节内存，取值范围：-128~127
short:2字节内存，16位，取值范围：-2^15~ 2^15-1
int:4字节内存，取值范围：-2^31~ 2^31-1
long:8字节内存，用后缀L来表示，取值范围：-2^63~ 2^63-1
float:4字节内存，用后缀F/f来表示，存储float型数据时保留8位有效数字
对于1和二，八，十六进制的数字后面不加f也是正确的float变量的声明
例：float f=1;float f=0x0123;
double:8字节内存

(2)字符型

char：两字节内存，单引号且引号内只能有一个字符，例：‘我’
char型数据一定是无符号的，而且不允许使用unsigned来修饰所声明的char型变量
转义字符：\n(换行),\b(退格),\t(水平制表),‘(单引号),"(双引号),\(反斜线)
\t：在打印时，将前面的字符串长度补齐到8，或8的整数倍，最少补一个，最多补8个
例：char c1=’\n’,c2=‘"’,c3=‘\’;
如果要观察一个字符在unicode表中的顺序位置，则可以使用int型类型转换，例：（int）‘A’。
如果要得到一个数字（0-65535）的数在Unicode表中的对应字符，必须使用char型类型转换，例：（char）65;

(3)布尔型

boolean

(4)空类型

null,一个特殊值，空值，null是不能直接打印的

2.引用数据类型

  数据值是存储在其他空间中的，自己空间中存储的是地址值
  赋值给其他变量，赋的是地址值

（1）类class

Java最基本的组成单元

（2）接口interface

（3）数组

一维数组
二维数组
数据分组管理

（4）枚举enum

（5）字符串String

字符串类型：用双引号，例：“hello”

（6）注解Annotation——>表真假

3.数据类型转换

—基本数据类型转换
数字进行运算时，数据类型不一样不能进行运算，需要转成一样的。
（1）级别低的向级别高的进行转换——>隐式转换
精度小的与精度大的进行运算，小的会先提升为大的在进行运算。
byte,short,char，三种类型的数据在运算时都会先提升到int在进行运算。
（2）级别高的向级别低的进行转换——>强制转换
格式：目标类型名变量名=（目标类型）被强制转换的数据；
例：int a=100； byte b=(byte) a;

注：常见错误是在把一个double型的变量赋值给float型变量没有进行类型转换
—引用数据类型转换

自动类型转换
例：Person p=new Student();
强制类型转换
Student s=(Student)p;

运算符与表达式

1.算数运算符

加减运算符（+，-）

二目运算符，从左到右，操作元是整型或浮点型，优先级是4级
连续进行‘+’操作时，从左到右逐个执行
当‘+’操作中出现字符串时，这个‘+’是字符串连接符，会将前后数据进行拼接
当字符+字符/字符+数字时，会把字符通过ASCLL码表查询到对应的数字在进行计算。

乘除和求余运算符

二目运算符，从左到右，操作元为整型或浮点型，优先级是3级

2.自增自减运算符

单目运算符，操作元必须时整型或浮点型变量
x++/x- - 表示在使用x之后时x的值增/减1（先用后加）
++x/- -x 表示在使用x之前先使x的值增/减1（先加后用）

3.关系运算符

二目运算符，从左到右，运算结果是boolean型
< >= <= == != >
==号的比较原理：基本数据类型比较的是数据值，应用数据类型比较的是地址值

4.逻辑运算符

二目运算符，操作元必须是Boolean型
&&(与) ||（或） !（非） ^（异或）
短路逻辑运算符:&&,||
即当左边的表达式能确定最终结果，那么右边就不会参与运算了

5.赋值运算符

二目运算符，操作元必须时变量，优先级为14级，从右向左

6.位运算符

按位与运算
双目运算符，远算结果是一个整型数据
运算法则：如果a,b两个数据对应位都是1，则c的该位是1，否则是0。
如果b的精度高于a，则c的精度和b相同。
例：a:00000000 00000011 b:10000001 10101011
a&b=c:00000000 00000011
按位或运算
二目运算符，远算结果是一个整型数据
运算法则：如果a,b两个数据对应的位都是0，则c的该位是0，否则是1。
如果b的精度高于a，则c的精度和b相同。
例：a:00000000 00000011 b:10000001 10101011
a&b=c:10000001 10101011
按位非运算
单目运算符，远算结果是一个整型数据
运算法则：如果a对应位是0，则c的该位是1，否则为0.
例：a:00000000 00000011 a!=11111111 11111100
按位异或运算
二目运算符，远算结果是一个整型数据
运算法则：如果a,b对应位数据相同，则c的该位是0，否则为1。
如果b的精度高于a，则c的精度和b相同。
例：a:00000000 00000011 b:10000001 10101011
a^b=c:10000001 10101000

7.instanceof 运算符

二目运算符，左面操作元是一个对象，右面操作元是一个类
当左面的对象是右面的类或者子类创建的对象时，该运算符的运算结果是TRUE，否则是FALSE
例：if(a instanceof Student d){}
左边是对象（变量），右边是类，返回值是Boolean类型
作用：测试左边对象是否是右边类或者该类的子类创建的实例对象，如果是，则返回TRUE；否则返回FALSE。
使用注意事项：
先有继承关系，再有instanceof的使用
当该测试对象创建时右边的声明类型和左边的类其中的任意一个跟测试类必须得是继承树的同一分支或存在继承关系，否则编译器会报错。

延伸

运算符优先级中小括号（）优先于所有，所以尽量使用括号运算符来实现想要的运算次序

注释

单行注释//
多行注释/* */
文档注释/** */
注：编译器会解析注释的内容，如果注释中有编译器无法识别的字符，编译器会报错，停止编译过程，这也会导致注释内容或源文件发生变化。

输出基本型数据

System.out.print();
输出不换行
System.out.println();
输出换行
System.out.printf（“格式控制部分”，表达式1，表达式2，···，表达式n);
格式控制部分由格式控制符号%d,%c····和普通字符组成，普通字符原样输出，格式控制符号用来输出表达式的值。
%d:输出int型数据
%c:输出char型数据
%f:输出浮点型数据，小数部分最多保留6位
%s:输出字符串数据
%md:输出int型数据占m列
%m.nf:输出的浮点型数据占m列，小数部分保留n位

条件语句

1.if语句

关键词if后面的小括号（）内的值必须是Boolean类型

2.Switch开关语句

case穿透：语句中未写入break导致的
若多个case的语句体重复，则可利用case穿透简化代码//即输出相同时，可省略之上
例:

1.switch(a){
    case 1:
    case 2:
    case 3:
        System.out.print("输出一致");
        break;
}
switch(a){
    case 1，2,3:
        System.out.print("输出一致");
        break;
}

switch的两种写法

//第一种
switch(a){
    case 1:break;
    case 2:break;
    default:break;
}
//第二种
switch(a){
    case 1,2,3-> System.out.println("一");
    case 4,5,6-> System.out.println("二");
    case 7,8,9-> System.out.println("三");
    default->System.out.println("输入不正确");
}

延伸

if条件用于对范围的判断
Switch语句用于有限数据

循环语句

1.for循环

格式：
for（表达式1；表达式2；表达式3）{
若干语句
}
表达式2必须是一个值为Boolean型数据
对某一数据的遍历的两种for写法

//第一种
int[]a={1,2,3,4};
for(int i;i<a.length;i++){
    System.out.print(a[i]);
}
//第二种
for(int i1;a){
    System.out.print(a[i]);//循环变量i1依次取数组a中的每一个元素的值
}

2.while循环

括号中的值必须为Boolean型变量

3.do-while循环

格式：
do{
若干语句；
}while(表达式);

延伸

do-while与while的区别是do-while的循环体至少被执行了一次

数组

一维数组

数组的静态初始化
例：int []a=new int[]{1,2,3};
数组的动态初始化
例：int []a=new int[3];
System.out.print(a); // 输出结果为地址值
即 : [I@13221566 //地址值
[ :表示当前是一个数组
I ：表示当前数组里的元素都是int型
@：一个间隔符号（固定格式）
13221566：数组真正的地址值（十六进制）
注：对于char型数组不会输出数组a的引用，而是输出数组a的全部元素的值

二维数组

数组的静态初始化
例：int [][]a=new int[][]{{1,2,3},{3,2,1}};
数组的动态初始化
例：int [][]a=new int[3][4];
声明二维数组时，行数需确定，但列数可不确定
获取元素：System.out.print(a[0]); //表示获取二维数组中的第一个一维数组

延伸

int a[],b[]; //声明了一个一维数组a和一个二维数组b
数组长度：数组名.length
对数组进行从小到大的排序：java.util.Arrays.sort(数组名);
数组初始化：系统会给数组的每个元素给一个默认的值
初始化值的规律：
整数类型：0
字符类型：‘\u0000’——>代表空格
布尔类型：false
引用数据类型：null
将一个数组赋值给另一个数组，改变其中一个数组的值另一个数组中相应的值也会改变

方法

是程序的最小的执行单元

方法的定义

public static 返回值类型 方法名（参数）{
    方法体;
    return 返回值;
}

调用方法：方法名（实参）；
方法调用时，参数的数量与类型必须与方法定义中的小括号里面的变量一一对应。
定义需在调用之前
方法与方法之间是平级关系，不能互相嵌套定义
方法的编写顺序与执行顺序无关
return为结束方法，return语句下面不能能编写代码，应为永远执行不到，属于无效代码
使用方法的情况：1.某个代码重复使用 2.某个代码执行特定功能

方法的重载

在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能
每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
同一个类中，方法名相同，参数不同的方法。与返回值无关
参数不同：个数不同，类型不同，顺序不同

String

创建String对象的两种方式

直接赋值
例子：String name=“lisa”;
占用内存小，如果两个字符串的值相同，会复用串池的地址
通过new关键字来使用不同构造方法 1.public String() //创建空白字符串，不含任何内容
例子：

String s=new String();    //没有输出

public String(String original) //根据传入的字符串，创建字符串对象
例子：

String s=new String("abc");   //输出abc

public String (char []chs) // 根据字符数组，创建字符串对象
使用场景：当我们需要修改字符串的内容时
例子：

char[] chs={'a','b','c'};
String s=new String(chs);    //输出abc

public String(byte[] chs) // 根据字节数组，创建字符串对象
应用场景：在网络当中传输的数据都是字节信息，我们一般需要将字节信息进行转换为字符串。
例子：

byte[] bytes={97,98,99};
String s=new String (bytes);     //输出abc,将数字通过ASCLL码转化为对应字符

String类中提供的常见方法

比较

boolean equals 方法（要比较的字符串）
完全一样结果才是true,否则为false
例子：

String s1=new String("abc");
String s2="abc";
boolean result=s1.equals(s2);//输出为TRUE

boolean equalsIgnoreCase(要比较的字符串)
忽略大小写的比较

String s1=new String("abc");
String s2="Abc";
boolean result=s1.equalsIgnoreCase(s2);//输出为true

public char charAt（int index）
根据索引返回字符
public int length()
返回字符串长度
1.String substring(int beginIndex,int endIndex)
截取字符串中的一段
包头不包尾，包左不包右
只有返回值才是截取的小串
2.String substring(int beginIndex)
截取到末尾
String replace(旧值，新值)替换
注意：只有返回值才是替换之后的结果

StringBuilder

可以看成一个容器，创建之后的内容是可变的

构造方法
public StringBuilder()//创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)//根据字符串的内容，来创建可变字符串对象

注意点

java.lang.String 类代表字符串，定义在java.lang包中，所以使用时不需要导包，java程序中的所有字符串文字（例如“abc”）都为此类的对象。
字符串不可以改变，他们的值在创建后不能被更改。

Java API

应用程序编程接口,指的就是JDK中提供的各种功能的Java类

random

产生一个随机数
导包：import java.util.Random;
创建对象：Random r=new Random();
生成随机数：int number=r.nextInt(n);
//括号中填随机数的范围,若范围为n,则会产生[0，n-1]范围内的随机数

scanner

输入基本型数据
导包：import java.util.Scanner;
创建对象：Scanner sc=new Scanner(System.in);
接受数据：int i=sc.nextInt();
读取用户在命令行中输入的各种基本数据类型：
nextByte();nextShort();nextInt();nextLong();nextFloat();nextDouble();nextBoolean();
当用户需要输入字符时，需使用charAt(n)（获取字符串中的第n个字符，n从0开始计数）：
char a=sc.next().charAt(0);
当用户输入字符串时：String s=sc.nextLine(); 或 String sc=sc.next();
数据输入的两套体系：

nextByte();nextShort();nextInt();nextLong();nextFloat();nextDouble();nextBoolean();next();
第一套体系遇到空格，制表符，回车就停止接受数据，空格之后的数据会留给下一个需要输入的变量接受
2.nextLine();
第二套体系可取带空格，制表符的字符串，只有遇到回车时才停止接受数据。
数据输入的两套体系不能混用

权限修饰符

是用来控制一个成员能够被访问的范围的
可以修饰成员变量，方法，构造方法，内部类
作用范围：private<缺省/默认（即空着不写）<protected<public

作用范围

如果方法中的代码是抽取其他方法中的共性代码，这个方法一般也私有

private关键字

可以修饰成员（成员变量和成员方法）
被 private修饰的成员只能在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，需提供相应的操作：
1.提供“setXXX(参数)”方法，用于给成员变量赋值，方法用public修饰；
2.提供“getXXX()”方法，用于获取成员变量的值，方法用public修饰
//并且这两个方法没有static
面向对象
类（设计图）：是对象共同特征的描述
对象：是真实存在的具体东西
在java中，必须先设计类，才能获得对象
如何定义类？

public class 类名{
    1.成员变量（代表属性，一般是名词）
    2.成员方法（代表行为，一般是动词）
    3.构造器
    4.代码块
    5.内部类
}

如何创建类的对象？
类名对象名=new 类名（）；
如何使用对象？
访问属性：对象名.成员变量
访问行为：对象名.方法名（）
成员变量
类中方法外的变量；有默认的初始化值；内存位置：堆内存；随着对象的创建而存在，随着对象的消失而消失；整个类中有效
完整定义格式：修饰符数据类型变量名称=初始值；
一般无需指定初始值，存在默认值
局部变量
方法中的变量，形参；没有初始化值，使用之前需要完成赋值；内存位置：栈内存；随着方法的调用而存在，随着方法的运行结束而消失；当前方法中有效；
测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口。我们可以在测试类中创建Javabean类的对象并进行赋值调用
工具类：帮助我们做一些事情的，但是不描述任何事物的类
类名见名知意
私有化构造方法，目的是为了不让外界创建他的对象
方法需定义为静态的，方便调用

标准的Javabean类

用来描述一类事物的类，在Javabean类中，是不写main方法的
类名需要见名知意，成员变量使用private修饰
提供至少两个构造方法：
1.无参构造方法
2.带全部参数的构造方法
成员方法：
提供每一个成员变量对应的setXXX（）/getXXX(),如果还有其他行为，也需要写上
例（关于成员变量name）：

public void setName(String name){
    this.name=name;
}
public String getName(){
    return name;
}

构造方法

构造方法也叫构造器、构造函数
作用：在创建对象的时候，由虚拟机自动调用，作用是给成员变量进行赋值（初始化）的
构造方法的格式：

public class Student{
    修饰符 类名（参数）{
        方法体；
    }
}

无参数构造方法：初始化的对象时，成员变量的数据均采用默认值。
有参数构造方法：在初始化对象的时候，同时可以为对象进行赋值。
特点：
1.方法名与类名相同，大小写也要一致
2.没有返回值类型，连void都没有
3.没有具体的返回值（不能有return带回结果数据）
执行时机：
1.创建对象的时候有虚拟机调用，不能手动调用构造方法
2.每创建一次对象，就会调用一次构造方法
如果我们没有写任何的构造方法，那么虚拟机给我们加一个默认的空参构造方法
例：public Student(){
}
如果定义了构造方法，系统将不再提供默认的构造方法
构造方法的重载：带参构造方法和无参构造方法，两者方法名相同，但是参数不同，
推荐的使用方式：无论是否使用，都手动书写无参构造方法和带参构造方法

this关键字

成员变量：在类里，在方法外的变量
局部变量：在类里并且在方法里
this的作用：可以区分成员变量和局部变量
this的本质：代表所在方法调用者的地址值//可以用来表示方法的调用者
访问成员变量：this.成员变量//访问本类成员变量
this.成员方法（…）//访问本类成员方法
this.(…)//访问本类构造方法，当需要给一些参数默认值时
当成员变量和局部变量命名一致时：
System.out.println(age);//采用就近原则
System.out.println(this.age);//输出成员变量

super关键字

代表父类存储空间
super.成员变量//访问父类成员变量
super.成员方法（…）//访问父类成员方法
super（…）//访问父类构造方法

private关键字

是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被 private修饰的成员只能在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，需提供相应的操作：
1.提供“setXXX(参数)”方法，用于给成员变量赋值，方法用public修饰；
2.提供“getXXX()”方法，用于获取成员变量的值，方法用public修饰
//并且这两个方法没有static

封装

会告诉我们如何正确设计对象的属性和方法

对象代表什么，就得封装对应的数据，并提供数据对应的行为
例：人画圆，而画这个动作是根据圆的半径画的，所以行为画应写在圆类

static关键字

static表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量

静态变量
定义：被static修饰的成员变量
被该类所有对象共享
不属于对象，属于类
随着类的加载而加载的，优先于对象出现的
调用方式：类名调用（推荐）/对象名调用
非静态方法可以访问所有
静态方法
定义：被static修饰的成员方法
多用在测试类和工具类中，Javabean类中很少会用
静态方法只能访问静态变量和静态方法
静态方法中没有this关键字
调用方式：类名调用（推荐）/对象名调用

继承

java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立继承关系

public class 子类 extends 父类{}

什么时候用继承？
当类与类之间，存在相同共性的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码
一个子类只能继承一个父类，子类不能同时继承多个父类
子类a继承父类b，父类b继承父类c;父类c是子类a的间接父类，父类b是子类a的直接父类
每一个类都直接或者间接的继承与Object类
子类只能访问父类中非私有的成员
子类能继承父类中的哪些内容？//不代表调用
构造方法：非私有（no）private(no)
成员变量：非私有（yes）private(yes)//不能直接使用
成员方法：虚方法（yes）不是虚方法(no)
虚方法表
包括非private，非static，非final方法
只有父类中的虚方法才能被子类继承
继承中：成员变量的访问特点
就近原则：谁离我近，我就用谁
先在局部位置找，本类成员位置找，父类成员位置找，逐级往上
如果出现重名的成员变量：
sout(name);//从局部位置开始往上找
sout(this.name);//从本类成员位置开始往上找
sout(super.name);//从父类成员位置开始往上找
继承中：成员方法的访问特点
就近原则
this.eat();//从本类成员方法开始往上找
super.eat();//从父类成员方法开始往上找
继承中构造方法的访问特点
父类的构造方法不会被子类继承
子类中的所有构造方法默认先访问父类中的无参构造，在执行自己的
原因：子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
子类构造方法的第一行语句默认都是：super（），不写也存在，且必须在第一行。
如果想调用父类的有参构造，必须手动写super进行调用
方法的重写
当父类的方法不能满足子类现在的需求时，需要进行方法的重写
子类与父类的方法声明一致
@Override是放在重写后的方法上，可以校验子类重写时语法是否正确
加上注解后如果有红色波浪线，表示语法错误
只有被添加到虚方法表中的方法才能被重写
重写方法的名称、形参列表必须与父类中的一致
子类重写父类方法时，访问权限子类必须大于等于父类
子类重写父类方法时，返回值类型子类必须小于等于父类
建议：重写方法尽量与父类保持一致

多态

定义：同类型的对象，表现出的不同形态
表现形式：父类类型对象名称=子类对象；
多态的前提:
有继承/实现关系
有父类引用指向子类对象
有方法重写
优势
使用父类类型作为参数，可以接受所有子类对象
在多态形式下，右边的对象可以实现解耦合，便于扩展和维护
多态的弊端
不能调用子类的特有功能
解决弊端的方法
将定义的父类的变量进行强制类型转换
强制类型转化可以转换成真正的子类类型，从而调用子类独有功能
转换类型与真实对象类型不一致会报错
转换的时候用instanceof关键字进行判断
多态调用成员的特点
–变量调用：
编译看左边：javac编译代码时，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败
运行也看左边：java运行代码时，实际获取的就是左边父类中的成员变量的值
–方法调用：
编译看左边：javac编译代码时，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败
运行看右边：java运行代码时，实际运行的是子类中的方法//因为子类重写方法时将父类的方法进行了覆盖

包

包就是文件夹，用来管理不同功能的java类，方便后期代码维护
包名规则：公司域名反写+包的作用，需要全部英文小写，见名知意
全类名/全限定名：例：com.itheima.domain.Student
使用其他类的规则：
使用同一个包中的类时，不需要导包
使用java.lang包中的类时，不需要导包
其他情况都需要导包
如果同时使用两个包中的同名类，需要用到全类名

final关键字

用final修饰方法，表明该方法是最终方法，不能被重写
用final修饰类，表明该类是最终类，不能被继承
用final修饰变量，叫做常量，只能被赋值一次
final修饰的变量是基本类型：那么变量粗女户的数据值不能发生改变
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变

代码块

用{}括起来的代码

局部代码块
写在局部代码块中的变量随着}的结束而被清除，释放内存
构造代码块
写在成员位置的代码块
作用：可以吧多个构造方法中重复的代码抽取出来
执行时机：我们在创建本类对象的时候会先执行构造代码块在执行构造方法
静态代码块
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
使用场景：在类加载的时候，做一些数据初始化的时候使用

抽象方法与抽象类

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象方法：

将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样的，所以，在父类不能确定具体的方法体，该方法就可以定义为抽象方法
定义格式：
public abstract 返回值类型方法名（参数列表）；

抽象类：

如果一个类中存在抽象方法，那么该类就必须声明为抽象类
定义格式:
public abstract class 类名{}
作用：抽取共性时，无法确定方法体，就把方法定义为抽象的，强制让子类按照某种格式重写。
抽象类不能实例化
抽象类可以有构造方法，作用是当创建子类对象时，给属性进行赋值
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类

接口

用关键字interface定义：public interface 接口名{}
接口和类是实现关系，通过implements关键字表示
public class类名 implements 接口名{}
接口的子类（实现类）
要么重写接口中的所有抽象方法
要么是抽象类
接口就是一种规则，是对行为的抽象
接口不能实例化
接口和类的实现关系，可以单实现，也可以多实现
public class 类名 implements 接口名1，接口名2{}
如果实现多个接口，但各接口之间有重名的抽象方法，只需重写一次该重名方法
实现类还可以在继承一个类的同时实现多个接口
public class 类名 extends 父类 implements 接口1，接口2{}

接口中成员的特点

成员变量：
只能是常量
默认修饰符：public static final
构造方法：
接口中没有构造方法
成员方法：
只能是抽象方法
默认修饰符：public abstract

接口和类之间的关系

类和类的关系、
继承关系，只能单继承，不能多继承，但是可以多层继承
类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口的关系
继承关系，可以单继承，也可以多继承
注：如果实现类实现了最下面的子接口，则需重写父类等的所有抽象方法

异常

异常就是代表程序出现的问题
异常体系最上层的父类时Exception
异常的分类：
运行时异常：RuntimeException及其子类，编译阶段不会出现异常提醒。一般都是参数传递错误带来的问题。（如：数组索引越界异常）
编译时异常：编译阶段就会出现异常提醒的（如：日期解析异常）
异常的作用：
-异常是用来查询bug的关键参考信息
-异常可以作为方法内部的一种特殊的返回值，以便通知调用者底层的执行情况

JVM默认处理异常的方式：

把异常的名称，异常的原因及异常出现的位置等信息输出在了控制台；程序停止执行，异常下面的代码不会在执行了

抛出处理

throws
注意：写在方法定义处，表明声明一个异常，告诉调用者，使用本方法可能会有哪些异常

public void 方法()throws 异常类名1，异常类名2…{
    ……
}

编译时异常：必须要写
运行时异常：可以不写

throw
注意：写在方法内，结束方法；手动抛出异常对象，交给调用者；方法中下面的代码不在执行了

public void 方法(){
    throw new NullPointerExption();
 }

捕获异常

格式

try{
    	可能出现的异常的代码;
}catch(异常类名 变量名){
    异常的处理代码;
}

目的：当代码出现异常时，可以让程序继续往下执行
如果try中没有遇到问题，会把try里面的代码全部执行完毕，不会执行catch里面的代码
只有出现了异常才会执行catch里面的代码
如果try中遇到多个问题则需写多个catch与之对应
如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面
在JDK7之后，我们可以在catch中同时捕获多个异常，中间用|进行隔开，表示如果出现了A异常或者B异常的话，采取同一种处理方式。
如果try中遇到的问题没有被捕获，相当于try—catch的代码白写了，最终还是会交给虚拟机进行处理
如果try中遇到了问题，那么try下面的其他代码就不会执行了，直接跳转到对应的catch当中，执行catch里面的语句体，但是如果没有对应的catch与之匹配，那么还是会交给虚拟机进行处理
public String getMessage（）//返回throwable的详细消息字符串
public String toString（）//返回此刻抛出的的简短描述
public void printStackTrace()//把异常的错误信息输出在控制台，仅仅是打印信息，不会停止程序运行

自定义异常

定义异常类
写继承关系
如果是运行时异常：则继承RuntimeException
如果是编译时异常：则继承Exption
空参构造
带参构造

不同进制在代码中的表现形式

二进制以0b开头
八进制以0开头
十六进制以0X开头
十进制前面不加任何任何前缀
任意进制——>十进制：系数*基数的权次幂相加
十进制——>任意进制：除基取余，倒着拼

计算机的存储规则

Text文本：
1.数字：转为二进制存储
2.字母：查ASCLL码表转二进制
3.汉字：查ASCLL码表转二进制
Image图片：通过每一个像素点中的RGB三原色来存储
Sound声音：对声音波形图进行采样在存储

IDEA常用快捷键及推荐插件

ctrl+alt+t:作用是快速将一段语句写成循环/条件等语句。
psvm/main:回车即可输出：public static void main(String args[]){ }。
sout:回车即可输出：System.out.println();
ctrl+alt+l:自动的格式化代码
ctrl+SHIFT+/:选中多行进行注释
ctrl+alt+m:自动抽取方法
ctrl+p:显示方法参数
shift+F6:可一次性修改用到多处地方的此变量名称
alt+鼠标左键选中：可修改同一竖行上的变量
ctrl+alt+v:自动生成赋值符号的左边
ctrl+shift+u:使选中的字母全部变成大写
构造空参方法：按alt+Fn+insert/alt+insert，选择Constructor,点击最下边的Select None
构造带全部参数的方法：按alt+Fn+insert/alt+insert，选择Constructor,按住shift不松，点击最下面的的参数（即代表选中全部参数）/ctrl+a全选，点击OK
构造get和set方法：按alt+Fn+insert/alt+insert，选择Getter and Setter,ctrl+a全选，点击OK
插件PTG1秒生成标椎Javabean：
连接外网，点击file，点击setting，点击plugins,点击Markplace,在搜索框中输入ptg,点击install，在点击OK即可。
如何使用：右键单级击，点击ptg to javabean,

cmd命令提示符

cmd:在Windows中利用命令行的方式操作计算机，可以打开文件，打开文件夹，创建文件夹
常用cmd命令：
1.盘符名称+冒号
表示盘符切换，例：E:回车，表示切换到E盘
2.dir
表示查看当前路径下的内容
3.cd目录
表示进入单级目录，例：cd itheima
4.cd…
表示回退到上一级目录
5.cd目录1\目录2\……
表示进入多级目录，例：cd itheima\JavaSE
6.cd
表示回退到盘符目录
7.cls
表示清屏
8.exit
表示退出命令提示符窗口