Java基础1

Java基础1

Java程序开发与运行原理

1.编写源文件(.java)
2.通过调用javac.exe编译成字节码文件(.class)
3.通过调用java.exe运行字节码文件

IDEA常用快捷键

Ctrl + B 打开光标处的类或方法
Ctrl + D 复制光标所在行，并粘贴在下一行
Ctrl + Y 删除光标所在行或选中的行
Ctrl + N 通过类名定位文件
Ctrl + F 在当前文件进行文本查找
Ctrl + / 单行注释
Ctrl + Shift + / 多行注释
Ctrl + Alt + L 格式化代码
Ctrl + Alt + ← 退回到上次光标的位置
Ctrl + Alt + → 前进到下次光标的位置
Alt + Shift + ↑↓ 移动当前代码行

Java语言编码规范

1.花括号成对、对齐写
2.左花括号前有空格
3.代码缩进
4.方法和程序块之间加空格
5.并排语句加空格
6.运算符两侧加空格

Java程序的最小单位是类，1个java程序至少要有1个类。
main方法是程序的主入口，所有的代码都是从这里开始执行的。
Java程序的入口是main方法，main方法的格式是固定的：

public static void main(String[] args) {
     }

在控制台输出内容的语句：

System.out.println("要输出的内容");

println 等于 print 加上 换行
.idea目录和.iml文件是IDEA的配置文件，可以隐藏
src目录是代码源文件存放的目录
out是Java程序的输出目录，存放字节码文件
External Libraries是JDK的扩展类库

Process finished with exit code 0
进程以退出code 0 结束
exit code 0 表示程序执行成功，正常退出
exit code 1 表示程序执行过程中遇到某些错误，非正常退出
most recent call last 最近一次调用

注释：对程序做介绍、说明的文字
单行注释： // 注释内容
多行注释： /注释内容/ 打出/* 再回车即可
文档注释： /*注释内容/ 多用解释于类和方法

关键字：被Java语言赋予特定含义的单词
特点：全部小写；有特殊的颜色标记

常量：在程序执行过程中，其值不会发生改变
可分为字面值常量和自定义常量
字面值常量分类如下
字符串常量：“HelloWorld” 双引号
字符常量：‘a’, ‘0’ 单引号
整数常量：0
小数常量：12.34
布尔常量：true, false
空常量：null

“” 空字符串
" " 空格字符串

字符即单个符号；字符用单引号表示。
字符串即多个字符；字符串用双引号表示。
当需要对字符进行字符串拼接时，字符就用双引号表示为字符串。

main方法的快捷键：psvm
输出语句的快捷键：sout

变量：在程序执行过程中，其值可以在某个范围内发生改变的量

变量的本质是内存中的一小块区域
定义一个变量，其实是向内存申请一块内存地址
变量值可以修改，但内存地址不会改变!

变量的定义格式：
数据类型 变量名 = 初始化值；
数据类型：变量的变化范围

变量的使用：
直接通过 变量名 来使用变量

Java数据类型

计算机中，数值一律用补码表示和存储
计算机中最小的存储单元是字节(Byte)
1个Byte由8个bit组成
所以1个字节可以表示的数值范围为：
－2^7 ~ 2^7-1
浮点型表示的是精度范围，不是数值范围

变量的作用域：只在它（定义的位置）所属的代码块内有效
代码块：一对大括号｛｝范围内的代码，称为一个代码块

{
     
    int a = 1;
    {
     
        int b = 2
    }
}

int a = 1 这个变量在外边这个代码块内有效，而里边这个代码块属于外边代码块，所以这个变量子代码块内也有效。
即内部的可以使用外部的变量，外部的不能使用内部的变量

1.整数型默认是int类型，定义long类型变量的时候，初始化值后要加字母L
定义超过int取值范围的数字必须加L
而int可以自动转byte是语言特点
2.浮点数类型默认是double型，定义float类型变量的时候，后面要加字母F
float a = 1; // 对，1默认是int型，可以自动转换为float型
float a = 1.0;// 错，1.0默认是double型，取值范围比float大，不能自动转换。
*可以在1.0后面加F指明数据类型是float
float a = 1.0F;
*也可以手动强制转换
float a = (float)1.0;

数据类型转换
自动类型转换：
小类型与大类型运算，小类型（取值范围小）自动提升为大类型，运算结果为大类型（取值范围大）
小转大关系：
byte->short,char->int->long->float->double
boolean类型不参与比较，它的值只有true和false两种

强制类型转换：
手动将大类型转换为小类型，运算结果是小类型
格式：
小类型 变量名 = (小类型)大类型数据;
*当且仅当大类型数据可以转换为小类型时才转换，否则会造成精度损失。
double a = 5.1;
int b = (int)a; //有时候故意造成精度损失，来取整；b=5

标识(zhì)符
给类、方法、变量、常量等起名字的字符序列
组成：英文大小写字母、数字、下划线、美元符
定义规则：
不能以数字开头；
不能是关键字；
严格区分大小写。
命名规范：
类和接口：每个单词首字母大写
HelloWorld
变量和方法：从第2个单词开始，每个单词首字母大写 getName
常量：全部大写，单词之间用_隔开
MAX_VALUE
包名：全部小写，多级包名之间用.隔开，一般是公司的域名反写
com.baidu.www
包：其实就是文件夹，用来区分重名类的

运算符
对常量和变量进行运算操作的符号
表达式
用运算符把常量或变量连接起来的式子
表达式的类型为表达式运算结果的数据类型

算术运算符
Java中整数除以整数，结果还是整数；
/ 表示两数相除的商；
% 表示两数相除的余数；
浮点数参与运算，结果是浮点数类型；

加法运算：
加号两边是数值型数据时，直接进行加法运算；
加号两边有任意一边是字符串时，实际进行的是字符串拼接；
字符型数据参与算术运算时，用的是其对应的ASCII码值。
0～9 >>> 48～57
a～z >>> 97～122
A～Z >>> 65～90
System.out.println(‘a’ + 1);//98
System.out.println(“a” + 1);//a1

++、–的特点：
++自增1，–自减1
单独使用时，放在变量前后，效果一致
参与运算时：（按顺序理解）
放在变量前：先++，再进行其他运算；
放在变量后：先以原值进行其他运算，再++；
int a = 3;
int b = ++a; //a=4, b=4
int b = a++; //a=4, b=3

赋值运算符
+=，先+再=
short s = 1;
s += 1;//等价于 s = s + 1，也等效于 s++
有一个好处，自动强转
如果写 s = s + 1;就会报错，因为s为short类型，1默认为int类型，s + 1就为int类型，将int类型赋值给short类型，自然会报错。需要强制类型转换
s = (short)(s + 1);

关系运算符
关系运算符的结果都是boolean类型
==是等于运算符
= 是赋值运算符

逻辑运算符
逻辑运算符两端的数据类型是boolean
逻辑运算符的运算结果是boolean类型
&&：逻辑与，并且，条件都为真，结果才为真
||：逻辑或，或者，有一个为真，结果就为真
!：逻辑非，取反，真假互换

三元运算符
格式：关系表达式 ？ 表达式1 : 表达式2;
若关系表达式结果为true，则执行表达式1
若关系表达式结果为false，则执行为表达式2

Java流程控制结构

顺序结构

代码按照从上往下、从左往右的顺序，依次逐行执行

选择结构

if语句，一般用于区间值的判断；
switch语句，一般用于固定值的判断；

第一种格式：
if(关系表达式) {
     
    //语句体
}
如果关系表达式为true，则执行语句体；否则程序直接结束。
第二种格式：
if(关系表达式) {
     
    //语句体1
} else {
     
    //语句体2
}
如果关系表达式为true，则执行语句体1；否则执行语句体2。
第三种格式：
if(关系表达1) {
     
    //语句体1
} else if(关系表达式2) {
     
    //语句体2
} 
……
} else if(关系表达式n) {
     
    //语句体n
} else {
     
    //语句体n+1
}
数据测试：应该包括正确数据、错误数据和边界数据

switch语句
switch(表达式) {
     
    case 值1:
        //语句体1
        break;
    case 值2:
        //语句体2
        break;
    …
    default:
        //语句体n+1
        break;
}
 **case值是要跟表达式比较的值**

循环结构

使一部分代码按照次数或一定的条件反复执行的一种代码结构

三种循环区别：
1.while和do…while循环语句的初始化语句、控制条件语句可以省略；
2.for循环初始化语句仅在循环内可用；
3.do…while循环至少执行1次；
4.for循环一般用于循环次数固定的，
while循环一般用于循环次数不固定的，
do…while循环一般用于先循环再判断的场景。

for(初始化语句;判断条件语句;控制条件语句) {
     
    //循环体
}
快捷键：fori
判断条件为true →执行循环体 →控制条件语句
继续执行判断条件语句……
判断条件为false，则循环结束。

while循环语句格式：
//初始化语句
while(判断条件语句) {
     
    //循环体
    //控制条件语句
}
初始化语句和控制条件语句可以省略！

do…while循环语句格式：
//初始化语句
do {
     
    //循环体
    //控制条件语句
} while(判断条件语句);
这个顺序是：循环体 →控制条件语句 →判断条件语句
判断条件语句为true则继续循环，为false则循环结束。

死循环：
1.for循环
for(;;) {
     
    //循环体
}
2.while循环
while(true) {
     
    //循环体
}

break：中断
在switch语句中，表示结束switch代码块；
在循环语句中，表示结束循环。
结束的是break所在的循环，如果是多层嵌套循环，可以使用标号来结束指定循环；
标号:
for() {
     
}
break 标号;//结束指定循环
continue 标号;//跳转到指定循环，继续执行
continue：继续
表示结束本次循环，继续下次循环
 

Scanner
扫描仪，通过Scanner类 来扫描用户在控制台录入的数据

//1. 导包
import java.util.Scanner;
public class ScannerDemo {
     
    public static void main(String[] args) {
     
    //2. 创建键盘录入对象
    Scanner sc = new Scanner(System.in);
    //3. 接收数据
    int i = sc.nextInt();
    }
}
也可以自动导包 Alt + Enter

Random
产生随机数

//1.导包
import java.util.Random;
pubilc class RandomDemo {
     
    public static void main(String[] args) {
     
        //2.创建Random类的对象 
        Random r = new Random()
        //3.获取随机数
        int num = r.nextInt(10);
        System.out.println(num);
    }
}
其中10的意思是产生[0,10)的随机整数，前闭后开

方法

也叫函数，是完成特定功能的代码块。
格式：

修饰符 返回值类型 方法名(参数类型 参数名) {
     
    //方法体
    return 返回值；
}

void为无返回值类型
定义方法3个明确：
明确方法名；
明确参数列表；
明确返回值类型；
定义方法的注意事项：
1.方法必须定义在类中
2.方法与方法之间是平级的，不能嵌套定义
3.方法没有返回值时，返回值类型必须有且是
void
4.方法返回值类型为void时，return可以省略
5.return语句返回值的类型必须和定义的返回
值类型一致
6.return后不能再放置语句

调用方法
1.根据方法名直接调用
2.方法要什么类型的参数，你就给什么参数（不用加类型）
3.方法返回什么类型的值，你就用什么接收

形式参数：方法定义时的参数 parameter
实际参数：调用方法时传入的参数 argument

方法重载
在同一个类中的多个方法：它们的方法名相同，但参数列表不同。这种关系称为方法重载。与返回值类型和修饰符均无关。

方法签名：方法名 + 参数列表
通过方法签名可以唯一地确定一个方法，而与返回值类型无关。
所以 相同方法名和相同参数列表，但不同返回值类型的情况不允许出现。

public static void aa() {
     }
public static int aa() {
     }
这2个只能存在1个

参数列表不同：参数个数不同 和 对应位置的参数类型不同。

数组

为什么需要数组？
为了存储多个数据
数组是用来存储同一数据类型多个元素的容器
其中数据类型既可以是基本类型，也可以是引用类型。
基本类型比如int[] a，引用类型比如String[] s
String是类，本身也是引用类型

数组的定义格式

格式1：
    数据类型[] 数组名 = new 数据类型[长度]
格式2：
    数据类型[] 数组名 = new 数据类型[]{
     元素}
格式3：
    数据类型[] 数组名 = {
     元素}

数组名是变量名。
通过new开辟内存空间。
数组长度在定义时指定，不可更改。
数组的访问
通过数组的索引访问数组的元素
索引：也叫下标，是数组元素距离数组起始位置的偏移量。第一个元素的偏移量为0，所以数组的索引从0开始。
取值：数组名[索引]
赋值：数组名[索引] = 值；
数组的遍历
数组的长度：数组名.length
数组的最大索引为：数组的长度 - 1
数组中未手动赋值的元素，默认值为0
直接输出数组变量名，得到的是数组的内存地址
数组的初始化
在(堆)内存中为数组开辟连续空间，并为每个元素赋值的过程

int[] array={
     }; // 一个长度为零的数组
int[] array = null; //没有数组只有一个数组的引用，空地址
int[] array = new int[2]; // 有数组，长度为2，数组内元素为基本类型int，默认初始化为0
Object[] array = new Object[2]; // 有数组，长度为2，且数组内元素为引用类型，类Object，默认初始化为null

数组为什么是引用类型？
变量arr存储的是数组在堆内存中的地址值，而不是数组元素的值，变量arr通过内存地址引用堆内存中的数组

1个数组2个引用
int[] arr1 = new int[3];
int[] arr2 = arr1;
arr1和arr2共用一块内存空间，操作的是同一个数组

数组索引越界异常
ArrayIndexOutOfBoundsException
当访问了不存在的索引时，
空指针异常
NullPointerException
数组引用存储的值为null，而非数组的地址值时

int[] arr = new int[3];
arr = null;

引用类型传递和基本类型传递的区别
引用类型的变量作为参数传递给方法时，传递的是地址值；方法内修改影响原来的值，因为是对地址操作，调用方法后地址所对应的值已经改变

int[] arr1 = {
     1, 2, 3};
int num = nega(arr1);           // -1
System.out.println(arr1[0]);// -1
System.out.println(arr1[1]);// -2
System.out.println(arr1[2]);// -3

public static int nega(int[] arr) {
     
    arr[0] = -1;// -1
    arr[1] = -2;// -2
    arr[2] = -3;// -3
    return arr[0];
}

基本类型的变量作为参数传递给方法时，传递的是值；方法内修改不影响原来的值!

int x = 1;
int y = 2;
int z = sum(x, y);
System.out.println(x);// 1
System.out.println(y);// 2
System.out.println(z);// 3

public static int sum(int a, int b) {
     
    int c = a + b;// 3
    a++;             // 2
    b++;             // 3
    return c;
}

Java程序的内存分配

方法区：加载要运行的class文件，包含方法，静态成员，常量等
栈：方法运行时需要先进栈，特点是“先进后出”
比如说main方法，玩具子弹枪；创建对象的引用变量，指向堆内存中的对象；
存放的是指向对象的引用
堆：存储new出来的数组或对象，初始化其内容
存放的是对象本身

基本数据类型：被创建时，在栈上给其分配一块内存，用来直接存储数值内容；
引用数据类型：被创建时，首先在栈上给其引用变量分配一块内存，用来存储堆内存中的地址值；然后通过new关键字在堆内存中开辟连续空间，用来存储对象的具体内容；
Dog d = new Dog();
直接打印d得到的就是地址值；