JAVA-SE阶段性总结

目录

1、基础语法

2、面向对象

3、String 和异常

1、基础语法

在Java中数据类型主要分为两类：基本数据类型和引用数据类型。

注意：
不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
整形和浮点型都是带有符号的
整型默认为int型，浮点型默认为double
字符串属于引用类型

类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
1. int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b;  // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b;  // 编译成功：a + b==>int + long--->long + long 赋值给long

2. byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
        byte c = a + b;

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算.

正确的写法:

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

基本运算符

1. 基本四则运算符：加减乘除模(+ - * / %)

2. 增量运算符 += -= *= %=

3. 自增/自减运算符 ++ --

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

&& 和 || 遵守短路求值的规则：

对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.
1. 按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

2. 按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

3. 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

4. 按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

1. 左移 <<: 最左侧位不要了, 最右侧补 0.

2. 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

3. 无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

程序逻辑控制

if语句

if(score >= 90){
  System.out.println("优秀");
}else if(score >= 80 && score < 90){
  System.out.println("良好");
}else if(score >= 70 && score < 80){
  System.out.println("中等");
}else if(score >= 60 && score < 70){
  System.out.println("及格");
}else if(score >= 0 && score < 60){
  System.out.println("不及格");
}else{
  System.out.println("错误数据");
}

switch语句

int day = 1;
switch(day) {
  case 1:
    System.out.println("星期一");
    break;
  case 2:
    System.out.println("星期二");
    break;
  case 3:
    System.out.println("星期三");
    break;
  case 4:
    System.out.println("星期四");
    break;
  case 5:
    System.out.println("星期五");
    break;
  case 6:
    System.out.println("星期六");
    break;
  case 7:
    System.out.println("星期日");
    break;
  default:
    System.out.println("输入有误");
    break;
}

注：千万不要遗漏break

while循环

例：计算 1! + 2! + 3! + 4! + 5!

int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
  int factorResult = 1;
  int tmp = 1;
  // 里层循环负责完成求阶乘的细节.
  while (tmp <= num) {
    factorResult *= tmp;
    tmp++;
 }
  sum += factorResult;
  num++;
}
System.out.println("sum = " + sum);

break 的功能是让循环提前结束.

例：找到 100 - 200 中第一个 3 的倍数

int num = 100;
while (num <= 200) {
  if (num % 3 == 0) {
    System.out.println("找到了 3 的倍数, 为:" + num);
    break;
 }
  num++;
}
// 执行结果
找到了 3 的倍数, 为:102

continue 的功能是跳过这次循环, 立即进入下次循环.

例：找到 100 - 200 中所有 3 的倍数

int num = 100;
while (num <= 200) {
  if (num % 3 != 0) {
    num++;  // 这里的 ++ 不要忘记! 否则会死循环.
    continue;
 }
  System.out.println("找到了 3 的倍数, 为:" + num);
  num++;
}

for循环

例：计算 1! + 2! + 3! + 4! + 5!

int sum = 0;
for (int i = 1; i <= 5; i++) {
  int tmp = 1;
  for (int j = 1; j <= i; j++) {
    tmp *= j;
 }
  sum += tmp;
}
System.out.println("sum = " + sum);

2、面向对象

  面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

  类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

例：写一个狗类

class PetDog {
  public String name;//名字
  public String color;//颜色
  // 狗的属性
  public void barks() {
    System.out.println(name + ": 旺旺旺~~~");
 }
 
  // 狗的行为
  public void wag() {
    System.out.println(name + ": 摇尾巴~~~");
 }
}

定义了一个类，就相当于在计算机中定义了一种新的类型。

用类类型创建对象的过程，称为类的实例化。

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

public class Date {
  public int year;
  public int month;
  public int day;
  public void setDay(int year, int month, int day){
    this.year = year;
    this.month = month;
    this.day = day;
 }
  public void printDate(){
    System.out.println(this.year + "/" + this.month + "/" + this.day);
 }
}

构造方法：名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

public class Date {
  public int year;
  public int month;
  public int day;
  // 构造方法：
  // 名字与类名相同，没有返回值类型，设置为void也不行
  // 一般情况下使用public修饰
  // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
  public Date(int year, int month, int day){
    this.year = year;
    this.month = month;
    this.day = day;
    System.out.println("Date(int,int,int)方法被调用了");
 }
  public void printDate(){
    System.out.println(year + "-" + month + "-" + day);
 }
  public static void main(String[] args) {
    // 此处创建了一个Date类型的对象，并没有显式调用构造方法
    Date d = new Date(2021,6,9);  // 输出Date(int,int,int)方法被调用了
    d.printDate();   // 2021-6-9
 }
}

封装：

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

static:

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

【静态成员变量特性】
1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student{
  public String name;
  public String gender;
  public int  age;
  public double score;
  public static String classRoom = "Bit306";
 
  // ...
 
  public static void main(String[] args) {
    // 静态成员变量可以直接通过类名访问
    System.out.println(Student.classRoom);
    Student s1 = new Student("Li leilei", "男", 18, 3.8);
    Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
    Student s3 = new Student("Jim", "男", 18, 2.6);
    // 也可以通过对象访问：但是classRoom是三个对象共享的
    System.out.println(s1.classRoom);
    System.out.println(s2.classRoom);
    System.out.println(s3.classRoom);
}
}

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。

继承：

面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

// Animal.java
public class Animal{
  String name;
  int age;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep(){
    System.out.println(name + "正在睡觉");
 }
}
// Dog.java
public class Dog extends Animal{  
  void bark(){
    System.out.println(name + "汪汪汪~~~");
 }
}
// Cat.Java
public class Cat extends Animal{ 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}
// TestExtend.java
public class TestExtend {
  public static void main(String[] args) {
    Dog dog = new Dog();
    // dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
    System.out.println(dog.name);
    System.out.println(dog.age);
    // dog访问的eat()和sleep()方法也是从Animal中继承下来的
    dog.eat();
    dog.sleep();
    dog.bark();
 }
}