字面量（常量）

image.png

标识符

image.png
标识符命名规范：（小驼峰、大驼峰）
image.png

基本数据类型：

image.png

获取一个数在每位上的数字

image.png

算数运算符

自增自减只能操作变量，不能操作常量
例题：
image.png

隐制转换：

小的给大的，允许直接给。
思路：数据类型不统一，不能直接运算。
byte short char 三种数据在运算的时候，都会提升为int,然后再运算

强制转换：

大的给小的，不允许直接给，需要强装。
image.png
例题：
image.png

扩展赋值运算符（+=…），自带强转效果。

三元运算符

image.png

if语句注意事项：

image.png

switch语句：

注意事项：

  1. case后面的值不允许重复。
  2. case后面只能是常量，不能是变量
  3. switch语句()中可以接受的类型：
    1. 基本数据类型 byte short char int
    2. 引用数据类型 ：
      1. dk5版本开始可以是枚举
      2. jdk7版本开始可以是String字符串

  4. 如何switch语句中，省略了break语句，将会开启case穿透现象。

    穿透现象的运用：发现多个case中，存在相同的代码逻辑。
    例题：
    image.png

while循环语句：

初始化语句；
while（条件判断语句）{
循环体语句；
条件控制语句；
}

do…while循环语句：

初始化语句；
do{
循环体语句；
条件控制语句；
}while（判断条件）;

do…while 特点：无论判断条件是否满足，都至少执行一次循环体

三种循环的区别：

image.png

跳转控制语句

break：
结束\终止，结束switch语句，也能结束循环语句。
注意：只能在循环和switch当中进行使用。

continue：跳过某一次循环的执行。
注意：只能在循环当中使用。

跳转控制语句共同的注意事项：下面不允许写代码，因为执行不到
如果遇到了循环嵌套，break和continue只能操作自己所在的那一层。

无限循环的三种代码：

  1. for(;;){
  2. }
  1. while(true){
  2. }
  1. do{
  2. }while(true);

数组

  1. 数据类型[] 数组名=new 数据类型[]{元素1，元素2...};
数据类型 [] 数组名={元素1,元素2...};

打印数组名：[I@119d7047]：数组的内存地址
@：分割符
I：当前空间中存储的数据是int类型
119d7047：十六进制地址值

数组长度：arr.length

例题：
image.png

数组的动态初始化：int[] arr=new int[长度];

默认初始化值：
整数：0
小数：0.0
布尔：false
字符：’\u0000’→unicode字符→常见的体现空白字符
引用数据类型（数组、类（包括字符串）、接口）:null

数组内存图4ff0ed4267d2ba616e2ea508776f099.jpg

数组常见问题：
1.ArrayIndexOutOfBoundsException:数组索引越界异常
原因：当访问了不存在的索引
2.NullpointerException:空指针异常
原因：当一个”引用数据类型”的变量，记录到一份null值之后，跟堆内存的指向被切断了，这时候还想去访问堆内存数据，就会产生空指针异常。

二维数组：

容器，该容器用于存储一维数组
使用思路：今后若要操作多组数据，属于同一组数据就可以考虑使用二维数组维护。
格式：int[][] arr={
{11,22,33},
{44,55,66}

遍历二维数组：

for (int i = 0; i < arr.length; i++) {//遍历二维数组，获取到每一个一维数组
for (int j = 0; j < arr[i].length; j++) {//遍历每一个一维数组，或缺到具体的元素
System.out.print(arr[i][j]+”\t”);

二维数组动态初始化：

方法一：
int[][] arr = new int[2][3];
arr[0][0] = 11;
arr[0][1] = 22;
arr[0][2] = 33;
arr[1][0] = 44;
arr[1][1] = 55;
arr[1][2] = 66;
方法二：
int[][] arr1 = new int[2][4];
int[] arr2 = {11, 22, 33,88};
int[] arr3 = {44, 55, 66,55};
arr1[0] = arr2;
arr1[1] = arr3;

方法

方法的常见问题

  1. 方法不调用就不执行。
  2. 方法与方法之间是平级关系，不允许嵌套定义。
  3. 方法的编写顺序和执行顺序无关，要想梳理执行顺序，就看调用顺序。
  4. 如一个方法的返回值类型为void，表示此方法是没用返回值，return语句不可省略。但如果非要写return的话，只能写成return；后面不能带具体在。
  5. return语句下面不能写代码，因为执行不到。
  6. 如一个方法有明确的返回值类型，一定要通过return语句带回一个结果。

    方法重载

    同一个类，方法名相同，参数不同的方法。
    识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关
    参数不同：个数不同，类型不同，顺序不同
    方法面试题.ppt

面向对象

成员变量和局部变量的区别：

区别 成员变量 局部变量
类中位置不同 方法外 方法中
初始值不同 有默认初始值 没用，使用之前需要完成赋值
内存位置不同 堆内存 栈内存
生命周期不同 随着对象的创建而存在，随着对象的消失而消失 随着方法的调用而存在，随着方法的运行结束而消失
作用域 在自己所归属的大括号中

this关键字：

this本质的作用，是调用本类成员（成员变量、成员方法）
表面作用：可以区分局部变量和成员变量的重名问题

谁来调用this，this就代表谁：哪一个对象调用的方法，方法中的this，就代表哪一个对象。

构造方法\构造器：

介绍：构建，创造一个对象的时候要执行的方法。
格式：

  1. 方法名需要和类名保持一致，大小写也必须一致。
  2. 没用返回值类型，连void都没有。
  3. 没用具体的返回值（不能通过return语句带回结果数据）。

构造方法执行时机：

  1. 在创建对象的时候，被系统自动调用执行。
  2. 每创建一次对象，就会执行一次构造方法。

构造方法的作用：

  1. 本质的作用：用来创建对象
  2. 结合执行时机：用于在创建对象的时候，给成员变量初始化

注意事项：

  1. 一个类中要是没写任何构造方法，系统将会提供一个[默认地][无参数的]构造方法，保证你可以创建对象。
  2. 一旦手动给出了构造方法，系统将不会再提供那个默认的无参构造。建议：今后写代码，[无参][有参]构造方法，全部手动给出。
  3. 构造方法不允许手动调用执行。

例题：
image.png

封装

隐藏实现细节，仅对外暴露公共的访问方式。
将属性抽取到类当中，这是对数据的一种封装。
将代码抽取到方法中，这是对代码功能的一种

JavaBean（对数据进行的一种封装）

  1. 所有的成员变量private私有化
  2. 提供出[空参][有参]构造方法
  3. 针对于私有的成员变量，提供SetXXX\getXXX方法

Set：设置\赋值
get：获取

API

API帮助文档的使用流程：
1.在索引的位置，搜索要查看的类文件。
2.看包
—java.lang—核心包—不需要导包
—r如果不是lang包下的内容，都是需要编写导包代码的。
3.看这个类的介绍
—明确出该类的功能，要知道这个类是做什么用的。
4.看这个类的构造方法
—因为使用一个类，具体就是要创建对象使用，创建对象要执行构造方法，所以要查看构造方法。
5.看这个类的成员方法（方法摘要）
1)看参数
①要不要参数？②要的话，要几个？要什么类型的？
2）看返回值
①看返回值类型是不是void
—不是→在调用方法后，需要找一个对应的类型的变量接收
—是→在调用方法，不需要找变量接收
3）看介绍：要知道这个方法做什么用的。

键盘录入字符串方法：

next（）：以【空格】【tab键】作为录入的结束标记
nextLine（）：以【回车换行-Enter】作为录入的结束标记
弊端：
1.next（）：录入数据不完整
2.nextLine（）：在这个方法调用之前，如果出现nextInt，丢失这一次录入机会
目前来说：
1.如果涉及到整数和字符串一起录入的情况
请选择：nextInt（） next（）
2.如果录入的数据全部都是字符串
请选择：nextLine（）

String类的特点：

  1. Java程序中，所有双引号字符串，都是String这个类的对象。
  2. String字符串一旦被创建，就[不可更改]—内容不可改变。
  3. String字符串虽然不可改变，但是可以被共享。
    1. 字符串常量池：当我们使用双引号创建字符串对象的时候，会先检查该数据在常量池中是否存在。
      1. 不存在：创建
      2. 存在：复用

  4. 字符串和字符数组之间允许相互转换。

    String类常见构造方法：

    1.public String （）：创建一个空白的字符串对象
    例：String s1=new String（）；
    2.public String(String s)：根据传入字符串，创建字符串对象
    例：String s2 =new String（”abc”）；
    3.public String(char[] chs):根据传入的字符数组，创建字符串对象
    例：char[] chs={‘a’,’b’,’c’}；
    String s3=new String(chs);

    字符串+号拼接的原理：

  5. 系统会[自动的]创建一个StringBuilder对象。

  6. 系统会[自动的]调用该对象的append方法，完成字符串拼接。
  7. 系统会[自动的]调用该对象的toString方法，完成类型转换。

    String类的成员方法

    比较的方法：

    public boolean equals（object anobject）：
    两个字符串之间做比较，比较内容，返回true,false
    public boolean equalsIgnoreCase（String anotherString）：
    两个字符串之间做比较，比较内容，返回true,false，忽略大小写

public char charAt(int index):根据索引找字符
public int length（）：返回字符的个数
例：String s=”itheima”；
for（int i=0；ichar c=s.charAt（i）；
}
注意：
String类中length（）→方法
数组中length→属性

截取的方法：

public String substring(int beginIndex):
根据传入的索引截取当前字符串，截取到末尾，并返回新的字符串
例：String s=”itheima”；
String result=s.subsyring（2）；
System.out.println(result)；→heima
public String substring(int beginIndex,int endIndex): (包含头，不包含尾)
根据传入的开始和结束索引，截取字符串并返回新的字符串
例：String s=”itheima”；
String result=s.substring(0,2);
System.out.println(result);→it

替换的方法：

public Stiring replace(CharSequence target,CharSequence replacement):
参数1：taregt:旧值
参数2：replace：新值
(同样要返回新的字符串)

切割的方法：

public String [] spilt(String regex):
根据传入的字符串参数，作为规则，切割当前字符串。
今后在做切割的时候，都以\为开头
regex→正则表达式：本质就是一个字符串，可以去指定一些规则

StringBuilder（能提高效率）

  1. 可变的字符序列。
  2. StringBuilder是字符串的缓冲区，可以将其理解为一种容器，该容器可以存储任意数据类型，但是，进入到这个容器的数据，都会变成字符串。

    StringBuilder的成员方法：

    1.public StringBuilder append(任意数据类型)：
    向缓冲区（容量）添加元素，并返回自己这个对象本身链式编程
    2.public StringBuildr reverse( );
    对缓冲区中的内容进行反转，并返回自己这个对象本身。
    3.public int length( );返回缓冲区中字符的个数。
    4.public String toString（）：将缓冲区的内容，转换为String类型返回。

    String→StringBuilder的转换：

    1.通过StringBuider的构造方法进行转换：
    String s=”abc”;
    StringBuilder sb=new StringBuilder(s);
    2.先创建StringBulider对象，再通过append方法进行转换：
    String s=”abc”；
    StringBuilder sb=new StringBuilder（）；
    sb.append（s）；

    StringBuilder→String的转换：

    1.直接通过toString方法即可
    StringBulider sb=new StringBuilder（”abc”）;
    String s=sb.toString( );

    集合基础

    数组中，存储的是对象，具体存储的是，对象的地址值。

数组：长度是固定不变的
集合：长度经常发生改变

ArrayList<> List=new ArrayList<>( )；（自动导容）
泛型：<>对集合中存储的数据，进行类型的限制。

  1. 打印集合的对象名，不会出现内存地址，而是元素的内容
  2. 使用的时候，不需要关心底层的数组，只需要关心实际元素即可。
  3. 集合不需要操心长度的问题。

    ArrayList的常用成员方法：

    1.增
    名字.add（）；向集合的尾部添加数据，返回是否添加成功的状态。
    名字.add（int index，E elemen）；插队添加
    2.删
    名字.remove（int index）；根据索引，删除集合中的元素
    名字.remove（元素）：根据元素删除集合中内容（有重复元素，只删第一个）
    —返回是否删除成功的状态
    3.改
    名字.set（int dex，E element）；修改指定索引位置，为对应的元素
    —返回被覆盖的元素
    以上三种方法的返回值，通常来说，都不需要接收。
    4.查
    名字.get(int index)；根据索引，获取集合中的元素
    名字.size（）；返回集合中的元素个数