java笔记1.0版

IDEA

JDK的组成：

JDK：JRE + 开发工具箱

JRE：JVM + 核心类库

JVM：java虚拟机，运行java程序

核心类库：java已经封装好的类

开发工具：javac，编译工具，把java文件编译成class文件

                   java：运行工具，用来执行class文件

java项目结构：

工程（Project）

模块（Module）

包（Package）

类（Class）

idea快捷键：

生成main方法mainpsvm

生成输出语句sout

复制一行代码ctrl+d

删除一行代码ctrl+y/x

移动一行代码ctrl+shift+上下箭头

格式化代码ctrl+alt+l

重命名shift+F6

单行注释ctrl+/

多行注释ctrl+shift+/

自动修正alt+l

格式化代码shift+alt+l

操作代码块ctrl+alt+t

生成for循环标识符.fori标识符.forr

同时选中多个相同内容shift+F6

选中代码上下文按下鼠标滚轮拖动

生成javabean（实体类）alt+insert

代码提示ctrl+p

跟进源码ctrl+b

基本数据类型

byte

short

int默认

long末尾+L

float末尾+F

boyble默认

char

boolean

变量的注意事项

变量要先声明才能使用数据类型 变量名;

变量与据类型一一对应

变量的使用范围，定义的那一行到“}”结束

在同一个范围中，不能定义同名的变量

变量使用之前需要先赋值

关键词、标识符

关键字

全部是小写的英文单词，在编译器会高亮显示

标识符

作用：给变量、类取名字

组成：数字、字母、_、$

要求：不能数字、开头不能是关键字、区分大小写

命名规范：变量命名，要符合标识符的组成、见名知意、小驼峰

类命名：要符合标识符的组成、见名知意、大驼峰

类型转换

表达式类型提升（小转大）

表达式的最终类型取决于当前表达式的最高类型

byte short char 会自动提升为int

强制类型转换（大转小）

格式：数据类型 变量名 = （数据类型）变量名;

弊端：可能导致精度丢失。如果是小数装换成整数，会直接丢掉小数部分

键盘录入

作用：实现从键盘输入数据到程序中

实现步骤导包  import java.util.Scanner;

创建对象：Scanner sc = new Scanner(Sysem.in);

接收数据：整数      int a = sc.nextInt();

                        小数      double b = sc.nextDouble();

                        字符串    String  s = sc.next();

运算符

算术运算符

分类：+-*/%

/ 整数和整数相除结果只能是整数，要想得到小数，必须要有小数参与

%取余，获取两个数字相除的余数

一个数字是否为另外一个数字的倍数

奇偶数的判断

获取一个数字的任意位置上的值

+ 在字符串中的拼接规律

串前运算，串后拼接

自增自减运算符

表示方式：变量++/++变量，让变量本身的值+1

  变量-- / -- 变量， 让变量本身的值-1

参与运算的规律：

a++     先运算后自增

++a 先自增后运算

赋值运算符

分类：=

拓展赋值运算符

分类:+=-=*=/=%=

执行流程:

先用符号左边的变量，和右边的数据进行运算

把结果进行强制类型转换【转化为符号左边的数据的类型】

最后把结果赋值给左边的变量

关系运算符

作用：实现比较两个数字的大小的关系

分类：>>= <<===!=

注意事项：在Java中，使用 “==” 代表是否相等， "="代表赋值

逻辑运算符

作用:连接多个关系表达式

与:& 、&&

使用场景:表示多个条件需要同时满足

结论:有false则false

&、&&的区别：

&&多一个短路效应： 符号左边为false,右边就不执行了

或：| 、||

使用场景：表示多个条件只需要满足其中一个

结论：有true则true

| 、||的区别：

|| 多一个短路效应： 符号左边为true右边就不执行了

!取反

^相同为false，不同为true

三元运算符

作用：用于程序的判断，选择一种结果

格式：数据类型 变量名 = 关系表达式 ?  满足条件执行的值 : 不满足条件执行的值;

执行流程：

先执行关系表达式，

如果判断结果为true，则返回【满足条件的值】

如果判断结果为false，则返回【不满足条件的值】

分支语句、循环语句

switch

作用：选择分支去执行代码

格式：switch(值){

   case  值1:

语句体;

break;

case 值2:

语句体;

break;

....

default:

语句体;

}

执行流程：

用switch后面的值去匹配 case后面的值，

如果匹配上了就执行对应的语句体，

如果没有匹配上就执行default，

在swtich里面，遇到break,switch就结束了

特点：

switch后面的值的类型：byteshort  char  int枚举String

case后面接的值是不能相同的，只能是字面量，不能是变量

case后面如果不加break就会出现穿透现象

可以把case内容相同的代码，写在一个case 里面，然后其他的就通过case的穿透去执行，简化代码

if

作用：用于程序的判断

分类一：用于一种情况的判断

格式：

          if( 判断条件){

                  满足条件执行的内容;

}

执行流程：

先执行条件判断，如果判断满足，则执行if后面的内容，

如果判断不满足，就直接结束if，程序继续往下执行

分类二：用于两种情况的判断

格式：

if(判断条件){

满足条件执行的内容

}else{

不满足条件执行的内容

}

执行流程：

先执行判断条件，如果判断结果为true，就会执行if后面的内容，

如果判断结果为false，就执行else里面的内容

分类三：用于多种情况的判断

格式：

if(){

}else if(){

}else if(){

}else if(){

}...else{

}

执行流程：

从上往下执行判断，只要有一个判断结果为true，就执行对应的语句体，

如果所有的判断都为false,就执行else

for

作用:

重复执行某一段代码

获取一个范围的数据

格式:

for( 初始化语句 ①;  循环条件 ②; 迭代语句③){

循环体语句 ④;

}

执行流程:1  -> 2  -> 4 -> 3 -> 2 -> 4 ->3 .... 直到2的判断为false，循环结束

使用场景:在明确循环次数的时候

while

作用:

重复执行某一段代码

获取一个范围的数据

格式:

初始化语句; ①

while(循环条件 ②){

循环体语句；③

迭代语句；④

}

执行流程:1  ->  2 -> 3 -> 4  -> 2 .... 直到2的判断为false 循环结束

使用场景:不明确循环次数的时候

do...while

作用：

重复执行某一段代码

获取一个范围的数据

格式：

初始化语句；①

do{

循环体语句；③

迭代语句；④

}while(循环条件②);

执行流程：1 -> 3 -> 4 -> 2 -> 3 ->4 ...直到2的判断为false，循环结束

执行特点：先执行一次，后判断

死循环

概念：可以一直执行下去的循环

格式：

for( ;; ){}

while(true){}

do{}while(true);

使用场景：

做服务器

不明确循环次数的时候 ， 需要加上 break

循环嵌套

概念：循环里面有循环

格式：

for(){

for(){

}

执行流程：先执行一次外部循环，再执行一轮内部循环

跳转控制语句

break：结束当前的循环

continue：跳过本次循环的执行，进入到下一次循环

Random

作用：随机生成一个整数

怎么使用：

导包import java.util.Random;

创建对象Random r = new Random();

获取随机数int num = r.nextInt(整数);

代表随机数生成的范围[0,整数-1]

也可以代表生成随机数的个数

获取任意范围随机数：

任意版本的JDK[x , y]

r.nextInt(y - x + 1) + x;

JDK17之后获取随机数的方式：r.nextInt(x , y + 1);

使用场景：猜数字、随机点名

数组

作用：数组是一个容器，可以用来存放同种类型的多个值

格式：数组的静态初始化

概念：创建数组的时候，直接指定存储的元素

格式：

完整格式：

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

简写格式：

数据类型[] 数组名 = {元素, 元素...}

使用场景：

如果我们在存放数据时，已经知道具体的元素值，我们可以使用静态初始化

数组的动态初始化：

概念：

创建数组的时候，知道数组的类型和长度，但是不知道具体的元素

格式：数据类型[] 数组名 = new 数据类型[长度];

使用场景：

如果我们在创建数组的时候，只知道数据的类型和元素个数，不知道具体存放的数据，我们就可以使用数组的动态初始化

访问元素的方式：

访问元素：   数组名[索引]

就是数组元素的编号，从0开始，并且是连续的

修改元素：数组名[索引] = 值;

表示数组的长度：数组名.length

表示数组的最后一个元素：数组名[ 数组名.length - 1 ];

遍历格式：

for( int i = 0 ; i < 数组名.length ; i++){

使用i代替索引,

数组名[i] 就代表数组的每一个元素

}

内存分配：

方法区：存放 class文件信息， 存放static修饰的数据

栈内存：主要就是方法执行的内存区域，方法中定义的变量也是存在栈内存中

堆内存：主要是new出来的数据，整个空间有一个地址值作为标记，堆内存的数据有默认赋值 整数0，小数0.0，布尔值false，引用数据类型的数据、数组、String  null

方法

方法的概念：就是实现一个功能的代码块

好处:

抽取重复代码，提高代码的复用性

每一个方法就做一件事情，让方法的功能更加独立，方便我们后期的维护

完整格式:

public static void/返回值类型  方法名(数据类型   变量名 , 数据类型 变量名...){

}

无参无返回值方法:

定义格式:

public static void 方法名(){

}

调用格式:方法名();

有参无返回值方法

定义格式:

public static void 方法名(数据类型  变量名 , 数据类型 变量名...)               {

}

调用格式:方法名(值 ， 值...);

参数的作用:接收数据，提高代码的灵活性

有参有返回值的方法

定义格式:

public static 数据类型 方法名(数据类型 变量名 ，数据类型 变量名...){

}

调用格式:

直接调用:方法名(值, 值...); 【没有办法获取返回的数据】

赋值调用【推荐使用】:数据类型 变量名 = 方法名(值, 值...);

输出调用:sout(  方法名(值， 值...))

返回值的作用:为了把方法的结果返回给方法调用的方法去使用                

方法重载

概念:

同一个类中，相同的方法名字， 参数不同【参数的个数不同、对应位置的参数类型不同】

好处:

我们可以不用记那么多方法的名字

特点:

我们在调用方法的时候，JVM会根据我们参数类型，调用对应的方法

参数传递

基本数据类型:

方法中修改了数据，方法外不会变化

据类型引用数:

方法中修改了数据，方法外也会改变  【String 除外】

面向对象

类

类是用来描述【定义】：我们需要处理的数据，以及处理数据的方法

对象

概念：通过类来创建出来的，用来存放数据，处理数据

对象的创建：类名 对象名 = new 类名(值， 值...);

变量的使用：对象名.属性名

方法的使用：对象名.方法名();

this

代表什么：本质上就是一个变量，方法被谁调用，this代表就是谁

作用：区分同名的成员变量和局部变量。有this修饰的变量就代表类中的成员变量

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

成员变量局部变量

定义位置上:

类中方法外、方法中方法中

初始化值:

有默认初始化值没有默认初始化值

内存区域:

堆内存栈内存

作用域:

整个类中都可以使用只能在方法中使用

生命周期:

随着对象共存亡随着方法共存亡

构造器

格式：修饰符  类名(){}

特殊点：

无返回值，也没有 void

方法名一定要和类名一致

作用：

创建对象

初始化成员变量

注意事项：

系统默认给我们提供一个无参构造器

如果我们写上了构造器，系统就不会给我们提供了，我们需要手动加上无参构造器

封装【JavaBean】：

封装的概念

 广义上：  我们把需要处理的数据，以及处理数据的方法放在一个类中

 封装是Java的三大特征之一

封装的规范：合理隐藏，合理暴露

实现的步骤：

 我们需要私有所有的成员变量

对外提供公共的setXxx方法和 getXxx

对外提供无参构造器和满参构造器

String

包

作用：分门别类去管理Java程序

注意事项：

同包下的类，不需要导包

不同包下的类，就需要导包， 在类上写上 import 包名.类名

如果使用JDK提供的类，java.lang包下的类不需要导包，其他的包下的类需要导包

一个java类中，如果需要用到多个同名的不同包下的类，只能导入其中一个类，其他的类就需要通过包名.类名的方式去使用

api帮助文档的使用

在【索引处】输入我们要搜索的类

看当前类是属于哪个包下的

先看类的介绍

再看构造器

最后看方法

方法的名字

通过名字可以猜测方法的作用

看是否需要传递参数

看是否有返回值

最后再看方法的描述

String封装数据的两种方式

通过双引号的方式封装数据

存在于堆内存中的字符串常量池中：数据只有一份，第一次会创建，后面就是共享

通过构造器去new封装数据

每new一次对象，就创建一个新的对象

String的常用方法

获取字符串的长度int length();

根据索引获取对应位置的字符char charAt(int index)

把字符串内容转换为一个字符数组char[] toCharArray();

判断两个字符串内容是否相同boolean equals(Object obj)

判断两个字符串内容是否相同【忽略大小写】boolean equalsIgnoreCase(String str)

字符串内容的截取，从指定索引到另外一个索引String substring(int beginIndex, int endIndex)

字符串内容的截取，从指定索引到末尾String   substring(int beginIndex);

字符串内容的替换String replace(String 旧值， String 新值)

字符串内容的分割String[]  split(String 分割符号)

判断字符串中是否包含指定的内容boolean contains(String str)

判断字符串是否以指定的内容开头boolean startsWith(String str)

ArrayList

集合的作用

它是一个容器，它可以用来存放同种类型的多个值

跟数组的区别

数组的长度不可以改变【弊端】，集合的长度可以改变

数组可以存放任意类型的数据【基本数据类型和引用数据类型】

集合只能存放引用数据类型

基本数据类型对应的应用数据类型

• char        Character
• int                 Integer
• 其他的首字母大写

集合中的泛型的作用

ArrayList<E>

用于指定集合存放的数据的类型

集合的常用方法

增

add(E e)

add(int index , E e)

删

remove(int index)

remove(Object obj)

改

set(int index, E e)

查

E  get(int index);

大小

size()