Java基础知识(简单整理)

1 Java的标识符

1. 由字母 数字 下划线 美元符号 组成
2. 不能以数字开头
3. 严格区分大小写
4. 见名之意，并且不要使用拼音或者中英文夹杂的方式
5. 不能使用关键字

2 Java的关键字

1. 被Java提前指定好的全小写单词，一共有50个
2. 2个保留字：const 与 goto ,目前还没有明确意义的关键字
3. 还有3个不可以用作标识符的单词：true false null

3.数据类型

3.1基本类型byte short int long float double char  boolean 3.2引用类型String，这个类型的数据需要使用双引号包裹

4.类型转换

1. boolean类型不参与类型转换
2. 小转大，直接转 – 隐式转换
3. 大转小，强制转 – 显式转换，格式：byte b = (byte) a;
4. 浮变整，小数没 – 浮点型转整形是直接舍弃所有的小数部分的，不会四舍五入
   类型能否转换，取决于类型的取值范围，而不是字节数，字节数只能做大概的参考

5.运算符 

普通的四则运算符 + - * / ,普通的四则运算,并不能直接改变变量本身的值,除非 i = i*10+8
取余 % 6%4=2 6%3=0(余数为0表示整除)
自增自减运算符
可以改变变量本身的值
2)前缀式: 符号在前,先改变变量本身的值(+1/-1),再使用(打印/参与运算…)
3)后缀式: 符号在后,先使用(打印/参与运算…),再改变变量本身的值(+1/-1)
4)注意:不管是前缀式还是后缀式,一定是会改变变量本身的值,区别在于执行的时机不同
比较运算符
比较运算符最终的结果是布尔类型的
< >= <=

== 比较的是左右两边的值是否相等 !=比较的是左右两边的值是否不相等
逻辑运算符
双与/短路与/&& :判断逻辑与&一致,增加了短路的功能全真才真,有假则假
2)双或/短路或/|| :判断逻辑与|一致,增加了短路的功能全假才假,有真则真
注意:我们这里所说的短路,是指在某些情况下,表达式后半部分就不用计算了,因为我们已经知道了结果,也就是被短路了,短路可以提高程序的性能,但是短路不一定会用到
三目运算符: 1 ? 2 : 3; 1是表达式,1真取2,1假取3
复合赋值运算符:+= -= *= /=是一种简写的形式,比较方便,运算时会自动进行类型转换
赋值运算符: = ,右边给左边
拼接功能:+
位运算符 : 主要参与的是二进制的运算
&与:全真才真
| 或:全假才假
^异或:相同为0 不同为1
~ 非: 非0为1,非1为0
优先级控制:如果表达式的运算比较复杂,需要控制优先级,可以使用小括号

6.流程控制

  1.顺序结构：

     是指程序一行一行的向下执行的

  2.分支结构：单分支结构  多分支结构  嵌套分支结构

  3.选择结构：switch

  4.循环结构：for循环 while循环  do-while循环

 7.方法

1. 格式: 修饰符 返回值类型 方法名(参数列表){ 方法体 }
2. 如何确定我们要调用哪个方法呢?方法名+参数列表
3. 方法的重载:在同一个类中出现多个方法名相同,但参数列表不同的方法
4. 方法的传值 : 如果方法的参数类型是基本类型,传入的是实际的字面值,如果是引用类型,传入的是地址值
5. 方法的重写: 子类继承了父类以后,想要在不改变父类代码的情况下,实现功能的修改与拓展

8.数组

1.数组的创建方式:
静态创建 int[] a = {1,2,3,4,5};
静态创建 int[] a = new int[]{1,2,3,4,5};
动态创建 int[] a = new int[5]; 后续可以动态的给数组中的元素赋值
注意:不管是什么样的创建方式,都需要指定数组的类型与长度
2.我们可以通过数组的下标来操作数组中的元素
数组下标从0开始,最大下标是数组的长度-1,如果访问到了不是这个数组的下标,会出现数组下标越界异常
比如:a[5]表示的就是数组中的第6个元素
3.数组的长度:数组一旦创建,长度不可改变,长度指的是数组中元素的个数a.length,并且数组的长度允许为0:[ ]
4.数组的创建过程:
根据数组的类型与长度开辟一块连续的内存空间
对数组中的每个元素进行初始化,比如int数组的默认值就是0
生成数组唯一的一个地址值,交给应用类型变量a来保存
后续可以根据数组的下标再来操作数组中的具体元素
注意: 数组名a这个变量,保存的是数组的地址,不是数组中的具体元素

5.数组的工具类Arrays
toString(数组名) : 除了char类型的数组以外,其他类型的数组想要查看具体元素,需要使用本方法,否则打印的是地址值
copyOf(原数组名,新数组的长度) : 用来实现数组的复制 扩容 缩容
如果新数组的长度 > 原数组长度,就扩容,反之,则缩容,如果两者长度一致,就是普通的复制数组
注意:一定是创建了新数组,而不是对原数组的长度做操作
6.数组的遍历
一般习惯使用for循环,循环变量代表的就是数组的下标,从0开始,最大值是a.length-1
7.冒泡排序 :
外层循环控制比较的轮数,所以循环变量从1到n-1轮,代表的是轮数
内层循环控制的是这一轮中比较的次数,而且是数组中两个相邻元素的比较,所以循环变量代表的是数组的下标 

9.面向对象OOP 

9.1面向对象与面向过程

1. 两者都是一种编程的思想
2. 面向对象强调的是事情的结果，我们通过对象完成对应的功能
3. 面向过程强调的是事情的过程，我们做任何事情，都要亲力亲为，经过每一个步骤
4. Java是一门面向对象的语言

9.2 类与对象

   定义类通过关键字class来定义，类是一类事物的抽象，它是抽象的，它是模板
   创建对象通过new关键字触发构造函数生成，对象是根据类创建出来的具体的内容
   一个类可以创建出多个对象，对象是根据类的设计来创建的，所以对象具有类的所有属性与功能
   对象之间是相互独立的，互不影响。我们把创建对象也称作“实例化”

9.3面向对象的三大特性：封装

   前提：为了保证数据的安全，也为了程序的使用者能够按照我们预先设计好的方式来使用资源
   封装属性：用private修饰我们的属性
   然后为属性提供对应的getXxx()【获取属性值】与setXxx()【设置属性值】
   封装方法：用private修饰方法，被修饰的方法只能在本类中使用，所以我们在本类的公共方法里     调用这个私有方法
   外界如果想要使用这个私有方法的功能，只需要调用这个公共方法就可以了

9.4 面向对象的三大特性：继承

   前提 ：继承可以实现程序的复用性，减少代码的冗余
   我们通过extends关键字建立子类与父类的继承关系：格式：子类 extends 父类
   继承相当于子类把父类的功能复制了一份，包括私有资源
   注意：虽然私有资源继承了，但是私有资源不可用，原因是被private限制了访问，私有资源只能     在本类使用
   注意：构造方法不能继承，原因是：构造方法要求名字是本类的类名，我们不能在子类中出现父     类名字的构造方法
   继承是可以传递的：爷爷的功能会传给爸爸，爸爸的功能会传给孙子
   注意：爸爸从爷爷那里继承的功能，也会一起传给孙子
   Java的类是单继承的：一个子类只能有一个父类，但是一个父类可以有多个子类
   子类在继承了父类以后，如果对父类的功能不满意
   可以在不修改父类功能的【满足OCP原则】前提下，在子类中，重写继承过来的这个方法
   重写需要满足的规则：两同 两小 一大，我们可以在重写的方法上加@Override注解验证是否写       对
   继承是一种is a的关系，强耦合，关联性特别强，而且类的继承机会只有一次，要谨慎使用
   子类可以直接使用父类的所有非私有资源

9.5 面向对象的三大特性：多态

  前提：为了忽略子类型之间的差异，统一看作父类类型，写出更加通用的代码
  比如：把Cat看作Animal,把Dog看作Animal,把Bird看作Animal,如果方法需要设置传入的参数，可    以buy(Animal a)
  比如：把算术异常、输入不匹配异常都看作是Exception,统一捕获处理，只写一个解决方案
  概念：在同一时刻，同一个对象，代表的类型不同,拥有多种形态
  多态的要求：继承 + 重写
  多态的口诀1：父类引用指向子类对象：父类型的引用类型变量保存的是子类对象的地址值
  多态的口诀2：编译看左边，运行看右边：
  父类中定义的功能，子类才能使用，否则报错
  多态中，方法的定义看的是父类的，方法的实现看的是子类重写后的功能
 

10.构造方法 

   格式 ：修饰符 类名当做方法名（）{ } 注意：与类同名且没有返回值类型

11.对象创建

   前提：对象是根据类的设定来创建的，目前我们可以在类中添加很多的元素：
属性 方法 静态方法 构造代码块 静态代码块 局部代码块 构造方法…所以不限制类里具体写什么，取决于业务
对象创建的过程：Phone p = new Phone();
需要在堆内存中开辟一块空间，用来存放对象
对象需要完成初始化，比如对应的属性都有自己的对应类型的默认值
对象创建完毕后，会生成一个唯一的地址值用于区分不同的对象
将这个地址值交给引用类型变量来保存
后续如果想要使用这个类的功能，可以从引用类型变量中保存的地址值找到对应的对象做进一步的操作
匿名对象：new Phone();
匿名对象是没有名字的对象，所以创建过程：
需要在堆内存中开辟一块空间，用来存放对象
对象需要完成初始化，比如对应的属性都有自己的对应类型的默认值
对象创建完毕后，会生成一个唯一的地址值用于区分不同的对象
那么我们使用匿名对象只能使用一次，并且一次只能使用一个功能
new Phone().video();//创建匿名对象1，调用看直播的方法
new Phone().message();//创建匿名对象2，调用看发短信的方法

12.面向对象的其他知识点

静态代码块 static { }
位置：类里方法外
执行时机：随着类的加载而加载，最先加载到内存，优先于对象进行加载，直到类小消失，它才会消失
作用：一般用来加载那些只需要加载一次并且第一时间就需要加载资源，称作：初始化

构造代码块 { }
位置：类里方法外
执行时机：创建对象时执行，创建几次，执行几次，并且优先于构造方法执行
作用：用于提取所有构造方法的共性功能

局部代码块 { }
位置：方法里
执行时机：当其所处的方法被调用时才会执行
作用：用于限制变量的作用范围，出了局部代码块就失效

代码块之间的顺序：
静态代码块 -> 构造代码块 -> 构造方法 -> 普通方法【如果普通方法里有局部代码块，局部代码块才会执行】

static

被static修饰的资源统称为静态资源，可以用来修饰变量、方法、代码块、内部类
静态资源属于类资源，随着类的加载而加载，优先于对象进行加载，只加载一次
静态资源可以不通过对象，使用类名直接调用，不需要创建对象
静态资源只有一份，被全局所有对象共享
静态的调用关系：静态资源只能调用静态资源
静态资源是优先于对象的，所以静态资源不能与this和super共用

final 

final表示最终，不可以被继承，不可以被重写

被final修饰的是常量，值不可以被修改，注意常量定义时必须赋 

抽象

抽象的关键字是abstract
被abstract修饰的方法是抽象方法，抽象方法没有方法体
如果一个类中出现了一个抽象方法，那么这个类必须被abstract修饰
关于抽象类的特点：
1）抽象类中的方法不做限制 ： 全普 / 全抽 / 半普半抽
2）如果一个类中的方法都是普通方法，还要声明成抽象类，为什么？
为了不让外界创建本类的对象
3）抽象类不可以创建对象，所以常用于多态
4）抽象类中包含构造方法，但是不是为了自己创建对象时使用，而是为了子类的super()
5）抽象类中也是可以定义成员变量的
如果一个子类继承了一个抽象父类，有两种解决方案：
1）作为抽象子类：不实现/实现部分 抽象父类中的抽象方法 ： ”躺平”
2）作为普通子类：实现抽象父类中的所有的抽象方法 ： “父债子偿”
面向抽象进行编程：后天重构的结果

接口 

接口不是类，定义接口的关键字interface
如果一个类想要实现接口中定义的规则，需要使用implments与接口建立实现关系
注意：如果有任何一个抽象方法没有实现，那么这个类就是一个抽象子类
Java8中接口里的所有方法都是抽象方法
接口中只有静态常量，没有普通变量，会自动拼接public static final
接口中的方法也可以简写，会自动拼接public abstract
接口不可以实例化
接口中也没有构造方法，实现类调用的是它自己父类的构造方法，如果没有明确指定父类，那就是Object的
接口更多的是规则的制定者，不做具体的实现
接口降低了程序的耦合性，更加方便项目的维护与拓展
接口是先天设计的结果，这样可以省去后续的多次重构，节省资源

异常 

异常的继承结构
异常层次结构中的根是Throwable
Error：目前我们编码解决不了的问题
Exception:异常
编译异常：未运行代码就报错了，强制要求处理
运行时异常RunTimeException：运行代码才报错，可以通过编译，不强制要求处理
异常的解决方案
捕获处理try-catch–自己解决
向上抛出throws–交给别人解决，在方法定义的两个小括号之间throws,可抛出多个异常，用逗号隔开

基础API 

Object

1.是所有类的超类，Java中的类都直接或者间接的继承了Object
2.如果一个类没有明确指定父类，那么默认继承Object
3.Object处于java.lang包之下，不需要导包可以直接使用
4.toString()–我们日常使用最频繁的打印语句底层就调用了这个方法
如果没有重写这个方法，使用的是Object的默认实现，打印的是对象的地址值
如果重写以后，以重写的逻辑为准，比如String打印的是串的具体内容，比如ArrayList，打印的是[集合元素]
5.hashCode()–用于返回对象对应的哈希码值
如果是一个对象多次调用这个方法，返回的是同一个哈希码值
如果是不同的对象调用这个方法，应该返回的是不同的哈希码值
6.equals()–用于比较当前对象与参数对象是否相等
重写之前的默认实现比较的是两个对象的地址值
重写之后取决于重写的逻辑，比如String比较的是两个串的具体内容，比如自定义对象比较的是类型+属性值
7.equals()与hashCode()应该保持一致【要重写都重写】
解释：equals()底层默认实现比较的是==比较，地址值，重写后我们一般比较的是对象的类型+属性值
8.hashCode()不同的对象生成的哈希码值不同，那么与equals()的逻辑不匹配，所以也应该重写
重写后，是根据对象的类型与属性值来生成哈希码值，这样二者就一致了

String
1.String底层维护的是一个char[],而且String不可变，因为源码中的数组被final修饰了
创建方式：
2.char[] vlaues = {‘a’,‘b’,‘c’}; String s = new String(values);
String s = “abc”;有高效的效果，因为串存在堆中的常量池，第二次使用时就不再新建了

自动装箱与自动拆箱

 1.自动装箱：把基本类型的int包装成包装类型的Integer

 2.自动拆箱：把包装类型的integer拆箱成基本类型的int

高级API 

1. 字节输入流InputStream：

   InputStream--抽象父类--不能实例化

   FileInputStream--文件字节输入流-FIS

   BufferedInputStream--高效字节输入流-BIS

2. 字节输出流OutputStream：

   OutputStream--抽象父类，不能实例化

   FileOutputStream--文件字节输出流--FOS

   BufferedOutputStream--高效字节输出流-BOS

    3.字符输入流Reader：

   Reader--抽象父类--不能实例化

         FileReader--文件字符输入流-FR

         BufferedReader--高效字符输入流-BR  ​​​​​​​

 4.字符输出流Writer： 

   Writer--抽象父类，不能实例化

         FileWriter--文件字符输出流--FW

   BufferedWriter--高效字符输出流--BW