JAVA入门基础_JAVA基础知识（二）
JAVA基础知识
理解类、方法、修饰符、对象（实例）的含义
类
一个类相当于一个模板，我们可以使用类来创建对象（实例）
// 定义一个学生类，我们发现类中有着学生的状态和行为
class Student{
// 学生的姓名
String name;
// 学生的年龄
int age;
// 学生可以进行的打游戏行为
void playGame(){System.out.println("打游戏");}
// 学生可以进行的学习行为
void study(){System.out.println(name + "学习中");}
}
由上可知，类就是定义了状态和行为的模板。
方法的定义、如何组成
方法的定义
-
可以把方法理解为一个行为，需要用方法去达成某种目的。
-
例如一个方法的名字叫做add，主要是用于添加。
-
大致理解一下方法就是一组语句的集合，用于完成某个功能
如何组成
-
修饰符：告诉编译器如何调用该方法，定义了该方法的访问类型
-
返回值类型：该方法可能会返回一个值，而这里定义了会返回的值的类型，有一个特殊的返回值叫做void（无返回值的意思）
-
方法名：顾名思义，方法的名字，定义的规则需要遵循标识符的规范
-
传入的参数：方法名后的小括号中可以写多个参数，写的时候要遵循 参数类型 参数名的规则，在这里写的参数均为形式参数（当这个方法被使用时，传入的数据叫做实际参数），为了传递数据给方法使用。
-
方法体：就是方法中所编写的代码
该图片来自于菜鸟教程
修饰符
java中一共有4个访问修饰符，用于控制程序调用时的访问权限。
可以应用于类上、方法上、变量、常量
| 当前类 | 当前包 | 同一个包下 | 子类（同一个包下） | 子类（不同包下） | 不同包 |
|---|---|---|---|---|---|
| private | √ | ||||
| default | √ | √ | √ | ||
| protected | √ | √ | √ | √ | |
| public | √ | √ | √ | √ | √ |
| 当前类 | 当前包 | 同一个包下 |子类（同一个包下） | 子类（不同包下） | 不同包 |
| ------------ | ------------ | ------------ | ------------ | ------------ |
| private | √ | | | | |
| default | √ | √ | √ | √ |
| protected | √ | √ | √ | √ |
| public |√ | √ | √ | √ |√ |
对象（实例）
通过对类的理解，我们了解到类就是定义了状态和行为的模板，但是呢，我们发现并没有一个具体的学生。而对象就相当于是一个具体的学生，类就是一个学生的模板，而每一个具体的学生都是一个个的对象。
class Student{
// 学生的姓名
String name;
// 学生的年龄
int age;
// 学生可以进行的打游戏行为
void playGame(){System.out.println("打游戏");}
// 学生可以进行的学习行为
void study(){System.out.println(name + "学习中");}
}
public class Test{
public static void main(String[] args) {
// 创建一个学生
Student stu1 = new Student();
stu1.name = "张三";
stu1.age = 15;
// 创建第二个学生
Student stu2 = new Student();
stu2.name = "王五";
stu2.age = 19;
}
}
注释的含义及使用
注释是就是在编写程序时，用来给程序员自己看到数据，注释不参与编译跟运行。
// 这是一条单行数据（常用）
/*
这是一个多行注释，我是第一行（常用）
这是一个多行注释，我是第二行（常用）
*/
/**
我是一个DOC文档注释。
*/
变量、标识符及数据类型
什么是变量及分类
- 什么是变量？
变量就是可以变化的量。本质就是一片内存空间，这片内存空间中的数据可以灵活变换。 - 变量的分类
- 基本数据类型（由java定义）
- 引用数据类型（其实就是对象）
什么是标识符及命名规则
- 什么是标识符？
标识符：可以理解为自定义的英文名称，可以用于命名变量、方法、类、接口等。 - 标识符命名规则
只需要记住标识符的首个字符：只能是[a-z][A-Z]、数字、下划线_、美元符号$开头组成。不能包含其他的符号，并且不能以数字开头。
变量的基本数据类型
// 整数型
1.byte 字节类型，占据一个1个字节，1个字节等于8bit，有效范围为 2^7 ~ 2^7-1 -128~127
2.short 短整型，占据2个字节，有效范围为 2^16 ~ 2^16-1
3.int 整形，占据4个字节
4.long 长整形，占据8个字节
// 浮点型
5.float 单精度浮点型（小数类型），占据4个字节
6.double 双精度浮点型（小数类型），占据8个字节
// 字符型
7.char 字符型，占据2个字节
// 布尔型
8.boolean 布尔型，只有true（真）与false（假）两个值
在java中创建基础数据类型的变量
小提示，整数型的数据默认为int型，浮点型的数据默认为double型，如果需要使用long类型或float类型则需要在整数型数据最后加上L或者F(大小写都行)
public class VariableDemo {
public static void main(String[] args) {
// 整数型
byte b1 = 127;
short s1 = 246;
int i1 = 233;
long l1 = 44444L;
// 浮点型
float f1 = 1.254F;
double d1 = 2.268D;
// 布尔型
boolean bool1 = true;
// 字符型
char c1 = 'g';
}
}
变量的作用域以及成员变量、局部变量的称呼（暂时可以先不理解）
变量定义在方法中时（局部变量）
只有在当前方法中可以使用该变量
变量定义在类中时（成员变量）
该类中的所有方法都可以使用该变量，但是此种变量在各个对象当中是独立的。（例如该类有2个对象，那么对于这2个对象来说，每个类的变量都是独立的）
变量定义为static静态变量时（类变量）
可以直接使用类名调用，并且记住一点：只有静态可以调用静态。
当基础数据类型在进行 +（加） 运算时遇到String类型
任何基础数据类型在加了一个String类型的变量后，都会变成String字符串类型拼接。
例如：
int a = 3;
int b = 4;
String s = "";
// 结果为34
System.out.println(s + a + b);
基础类型之间进行运算的转换规则（整数型、浮点型）
向上转型
short s1 = 10;
short s2 = 13;
s1与s2进行计算时，会转换为int，因为int是java默认的整数类型。
byte byte1 = 10;
int int1 = 120;
切记 ： int1 + byte1 后，得到的数据类型是int，因为当相同类型的数据进行运算时，会将精度小的数据类型向精度大的数据类型转换。（向上转型）
float float1 = 12.1f;
double double1 = 13.2d;
根据上述文字描述，可知float1与double1进行计算时会将float1的数据转换为double的数据类型再进行计算。（向上转型）
向下转型
其实就是精度大的数据想要转换为精度小的数据，例如long想要转换为int，int想要转换为short等。
语法如下：
long long1 = 10L;
int int1 = (int)long1; // 将long类型的数据强制转换为int类型的数据
运算符
赋值运算符（=、+=、-=、*=、/=、%= 6个）
// 赋值运算符：=、+=、-=、*=、/=、%=
// 作用：用于给变量进行赋值，将等号右边的值赋值给左边的变量。
int a = 10;
char gender = '男';
| 运算符 | 称呼 | 作用 |
|---|---|---|
| = | 赋值 | 例如 int a =10，把10这个值赋给了变量a |
| += | 加等 | a+=b；等价为a = a + b |
| -= | 减等 | a-=b；等价为a = a - b |
| *= | 乘等 | a*=b；等价为a = a * b |
| /= | 除等 | a/=b；等价为a = a / b |
| %= | 模余等 | a%=b；等价为a = a % b |
算数运算符（7个）
加减乘除（+、-、*、/ 4个）
int a = 10;
int b = 3;
a + b; // 加法
a - b; // 减法
a * b; // 乘法
a / b; // 除法
取模运算（% 1个）
// 作用： 相当于求左边除右边后所剩下的余数。
int a = 5 % 2; // 1
int b = 5 % -2; // 1
int c = -5 % 2; // -1
int d = -5 % -2; // -1
%取余时，左右两边的符号小问题
当进行%取余时，只看左边值的正负符号。
例如上述案例当中，只有左边只是负的时候，得出的结果才为负。
自增自减运算符（++、-- 2个）
// 作用：相当于一个数进行 加一或减一 的操作
// 自增自减的符号可以添加到变量的左边或右边，例如： a++、++a、a--、--a
// a++ 的意思是当前表达式结束后在加一。 可以理解为碰到分号时，当前表达式结束。
// ++a 的意思是当前表达式结束之前再加一。
int a = 10;
int b = 20;
System.out.println(a++); // 10
System.out.println(++b); // 21
比较运算符（>、<、<=、>=、==、!= 共6个）
// 作用：比较运算符所获得的结果只能是boolean类型的，因此只有2个值，true或false
int a = 10;
int b = 20;
a > b; // 判断a是否大于b，false
a < b; // 判断a是否小于b，true
a >= b; // 判断a是否大于等于b，false
a <= b; // 判断a是否小于等于b， true
a == b; // 判断a是否等于b，false
a != b; // 判断a是否不等于b，true
==、!= 可以用来比较引用类型（比较地址）
逻辑运算符（&、&&、|、||、!、^ 6个）
// 逻辑运算符的运算结果也只有true或false，用于boolean类型的运算
| 运算符 | 称呼 | 作用 |
|---|---|---|
| & | 与 | true & false时，结果为false，运算符的左右边都必须为true才为true |
| && | 断路与 | true & false时，结果为false，与上不同的是，当左边为false时，不计算右边，直接得出结果为false |
| | | 或 | true & false时，结果为true，运算符的左右两边有任意一个true结果就为true |
| || | 断路或 | true & false时，结果为true，与上不同的是，当左边为true时，不计算右边，直接给出结果为true |
| ! | 非 | !true的结果为false，!false的结果为true，相当于取反 |
| ^ | 异或 | true ^ false 为true，true ^ true为false，false ^ false为false，当运算符左右两边不一致时，结果为true，否则为false |
位运算符(&、|、^、~、<<、>>、>>> 6个)
数据在计算机中的存储方式以及原码是什么
数据存储在计算机当中，都是以二进制的形式进行存储的。当将一个数转换为二进制时，那么就是这个数的原码。
数据在计算时，计算机会将其转换为补码形式进行运算。
补码：其实也是一种二进制的表示形式。
1、正数的补码等于它的原码。
2、负数的补码等于它的原码取反再+1，而负数的补码转换为原码的时候则需要 （-1 取反）也就是逆运算。
3、补码与原码进行转换时，符号位不变
各位运算符的作用
&：都为1时才为1，否则为0.
|：都为0时才为0，否则为1.
^: 相互不同时为1，否则为0.
~：取反，最高符号位也要取反
<<：左移，将数据向左移动，小提示：a左移一位为a * 2^1 ，a左移2位为 a * 2^2.（不包括符号位）
>>：右移，将数据向右移动，小提示：a右移一位为a / 2^1 ，a右移2位为 a / 2^2.（不包括符号位）
>>>：带符号右移，将数据向右移动（包括符号位）
&、|、^的计算步骤
int a = 10;
int b = 5;
// 如下计算步骤将省略一部分内容，例如转换成二进制时，很多个0没有写，取反的时候会都写
a & b的计算步骤如下：
1.将 a的值转换为二进制补码，10 > 1010
2.将 b 的值转换为二进制补码，5 > 0101
3.根据&计算的规则得到： 0000，因此得到a & b的计算结果为0.
a | b的计算步骤如下：
1.将 a的值转换为二进制补码，10 > 1010
2.将 b 的值转换为二进制补码，5 > 0101
3.根据 | 计算的规则得到： 1111，因此得到a | b的计算结果为15.
a ^ b的计算步骤如下：
1.将 a的值转换为二进制补码，10 > 1010
2.将 b 的值转换为二进制补码，5 > 0101
3.根据 ^ 计算的规则得到： 1111，因此得到a ^ b的计算结果为15.
~取反的计算步骤
int a = 10;
~a的计算步骤如下：
1.将a的值转换为二进制补码，由于正数的补码就是其原码，所以不用改变即可进行运算
00000000 00000000 00000000 00001010
2.将得到的数据取反（包括符号位）
11111111 11111111 11111111 11110101
3.由于现在最高符号位是1，因此是一个负数了，而负数的补码转换为原码则需要2步骤（分别是减-再取反）
3.1 先进行减一的操作
11111111 11111111 11111111 11110100
3.2 再进行取反的操作（符号位不用改变）
10000000 00000000 00000000 00001011
4.最后再将这个二进制转换为十进制
4.1 首先现在最高位（符号位）为1，因此是一个负数
4.2 除了最后的4位为1011，其他位都为0，因此1011转换为十进制为11
4.3 加上第一步确认的符号，因此最终结果为 -11.
<<、>>无符号左移、右移的计算步骤
int b = 6;
b<<1 的计算步骤如下：由于正数的补码就是其原码，所以不用改变即可进行运算
1.将b转换为二进制补码
00000000 00000000 00000000 00000110
2.将所有的值都向左边移动1位
00000000 00000000 00000000 00001100
3.将二进制转换为十进制，得到结果为12
int b = -6;
b>>1 的计算步骤如下：由于正数的补码就是其原码，所以不用改变即可进行运算
1.将b转换为二进制补码
10000000 00000000 00000000 00000110
2.将所有的值都向右边移动1位
10000000 00000000 00000000 00000011
3.将二进制转换为十进制，得到结果为-3
>>> 带符号右移的计算步骤
int b = -6; // b>>>1的计算步骤
1.因为b是一个负数，所以将b转换为二进制补码需要2个步骤（原码取反、加一）
1.1 得出b的原码
10000000 00000000 00000000 00000110
1.2 原码取反
11111111 11111111 11111111 11111001
1.3 取反后再加一
11111111 11111111 11111111 11111010
2.将符号全部右移1位
01111111 11111111 11111111 11111101
3.由于此时已经是一个正数了，所以补码就是原码，直接将其转换为十进制
4.得到结果为2147483645，你学会了么 ~^o^~
