偷掉月亮

月是故乡明

0%

发表于 更新于 分类于 ， Valine：

Java中二维数组

二维数组可以看成一维数组的每一个元素都包含一个一维数组。

尝试定义并且输出一个二维数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Arrays;

public class Test {
    public static void main(String [] args){
        int [] []array = {
                {0,0,0,0,0},
                {1,1,1,1,1},
                {2,2,2,2,2},
                {3,3,3,3,3}
        };
        //这里的array.length表示的是二维数组的行数
        for (int i=0;i<array.length;i++){
            System.out.println();
            for (int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]);
            }
        }

    }
    }

image-20220407181552628

二维数组的静态初始化：int a[][]=new int[2][3];建立一个两行三列的二维数组

二维数组的动态初始化：int a[][];a[][]=new int[2][3];

动态初始化-列数不确定性：int a[][]=new int[2][];即其列数可以不确定

杨辉三角

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Scanner;

public class Test {
    public static void main(String [] args){
        Scanner lineAccept=new Scanner(System.in);
        System.out.println("请输入您想要查看的杨辉三角的行数");
        int lineNum=lineAccept.nextInt();
        int[][] pascalTriangle =new int[lineNum][];
       for (int i=0;i<lineNum;i++){
           //将每一行中每一列的值定义下来
           System.out.println();
           int columnNum=i+1;
           pascalTriangle[i]=new int[columnNum];
           for (int j=0;j<columnNum;j++){
               if (j==0||j==i){pascalTriangle[i][j]=1;}
               else {pascalTriangle[i][j]=pascalTriangle[i-1][j-1]+pascalTriangle[i-1][j];}
               System.out.print(pascalTriangle[i][j]);
           }
        }
    }
    }

image-20220407181632501

发表于 更新于 分类于 ， Valine：

Java中数组基础

数组可以存放多个同一类型的数据，数组也可以认为是一种数据类型，是引用类型。

数组的初始化

动态初始化：数据类型 数组名[] =new 数据类型[大小]

int a[]=new int[5];创建了一个数组，名字为a，可以存放五个数据，数据可以后面定义。可以发现当定义之后默认为int类型数组每个数默认为0，自己可以采用循环的方式对其进行重新定义。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Arrays;

public class Test {
    public static void main(String [] args){
        int []array=new int[5];
        System.out.println(Arrays.toString(array));
        for (int i=0;i<array.length;i++){
            array[i]=i;
        }
        System.out.println(Arrays.toString(array));
    }
    }

image-20220407180622715

静态初始化：数据类型 数组名[]={元素1，元素2，元素3…..}；

int []array={1,2,3,4,5,6},表示int类型的数组，名称为array，包含1，2，3，4，5，6这六个元素，数组的大小不可以改变，但是数组的每一个值可以重新赋值改变。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Arrays;

public class Test {
    public static void main(String [] args){
        int []array={1,2,3,4,5,6,7};
        System.out.println(Arrays.toString(array));
        for (int i=0;i<array.length;i++){
            array[i]=i+10;
        }
        System.out.println(Arrays.toString(array));
    }
    }

image-20220407180652678

数组使用细节

  1. 数组是多个相同的类型数据的集合，实现对这些数据的统一管理。（如果为不同类型，则数组类型的精度要可以大于数组包含的值的精度） 

    1
    double []array={1.1,12,15};可以   int []array={1.1,12,15};不可以

  2. 数组创建后，如果没有赋值，则都是有默认值的。注意：boolean默认false，String默认为null，char默认为img点击并拖拽以移动。

  3. 数组的下标都是从0开始的

  4. 数组的下表不要出现越界异常。

  5. 数组属于引用数据类型，数组型数据的对象为object。

数组拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int []arr=new int[]{1,2,3,4,5,6,7,8,9};
        //现在我们需要拷贝这个数组
        int []arr1= Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.hashCode(arr));
        System.out.println(Arrays.hashCode(arr1));

        //同样我们现在需要扩展数组
        arr=Arrays.copyOf(arr,arr.length*2);
        System.out.println(Arrays.hashCode(arr));
        System.out.println(Arrays.hashCode(arr1));
        System.out.println(arr.length);


    }
}

image-20220706201240049

从上述的代码中我们可以发现，在拷贝之后，如果是数组大小相同，那么地址不会改变，但是如果改变了，地址也会改变。

main函数中数组作用

image-20220706202103530

我们尝试输出这个，发现会在我们运行的时候，在后面添加一些函数，会自动加入args这个数组里面，用于接收命令行上指定的参数

发表于 更新于 分类于 ， Valine：

我们平常运行一段代码，测试其方法，需要我们进行创建对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * @author 21050
 */
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.f1();
        animal.f2();
    }
}
class  Animal{
    public void f1(){
        System.out.println("我是方法一");
    }
    public void f2(){
        System.out.println("我是方法二");
    }
}

image-20220316153428486

这样比较麻烦，但是我们可以通过JUnit的方法进行使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @author 21050
 */

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.f1();
        animal.f2();
    }
}
class  Animal{
    @Test
    public void f1(){
        
        System.out.println("我是方法一");
    }
    public void f2(){
        
        System.out.println("我是方法二");
    }
}

发表于 更新于 分类于 ， Valine：

自定义泛型

class 类名<T,R>{}

  1. 普通成员可以使用泛型
  2. 使用泛型的数组，不能进行初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建对象时确定的（因为在创建对象时，需要指定确定类型）
  5. 如果在创建对象时，没有指定类型则默认为Object
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
    public static void main(String[] args) {

    }
}
class Tiger<T,M,R>{
    T[] ts;
    //不能使用静态static来定义泛型，会进行报错，static方法是在类加载的时候定义的，但是泛型是在初始化对象的时候进行的
    /*public static void f(M c){

    }*/

}

自定义泛型方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
    public static void main(String[] args) {
        Tiger tiger=new Tiger();
        //这个时候默认的就是String与int
        tiger.fly("haha",1);
        //这个时候默认的就是int与int
        tiger.fly(1,1);
    }
}
class Tiger<K>{
    public void run(){

    }
    //泛型方法被调用的时候必须指定泛型的类型
    public <T,R> void fly(T t,R r){

    }
    //这个并不是泛型方法
    public void f2(K k){
        
    }

}

注意泛型不具备继承性，下面的这一段语句就是错误的。

1
ArrayList<Object> arrayList=new ArrayList<String>();
: 支持A类以及A的子类，规定了泛型的上线 : 支持A类以及A的父类，规定了泛型的下线

发表于 更新于 分类于 ， Valine：

泛型说明

泛型的引入

  1. 不能够对加入集合的的数据类型进行约束（不安全）
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量比较大，对效率有影响

不使用泛型

我在添加狗对象的时候，不小心添加了一个猫对象，会报异常的错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import java.util.*;

public class Test {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add(new Dog("asc",15));
        arrayList.add(new Dog("ahn",15));
        arrayList.add(new Cat("ahn",15));
        for (Object o:arrayList){
            Dog dog=(Dog) o;
            System.out.println(dog.getName()+dog.getAge());
        }
    }
}
class  Dog{
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
class Cat{
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

}

而当我们使用泛型，就可以直接辨别出来我们加入的对象，并且在遍历的时候，我们可以直接传入Dog对象，而不是再次进行类型转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.*;

public class Test {
    public static void main(String[] args) {
        ArrayList<Dog> arrayList=new ArrayList<Dog>();
        arrayList.add(new Dog("asc",15));
        arrayList.add(new Dog("ahn",15));
        //arrayList.add(new Cat("ahn",15));
        for (Dog dog:arrayList){
            System.out.println(dog.getName()+dog.getAge());
        }
    }
}
class  Dog{
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
class Cat{
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

}

image-20220703174055627

image-20220703174109186

泛型理解

泛型又称数据化类型，是jdk5之后出现的新特性，解决数据类型安全性的问题，在类声明或实例化只要指定好需要的具体类型即可。泛型可以保证在程序编译时没有发生警告，运行时就不会产生ClassCastException的异常，同时代码更加简介，健壮。

泛型可以在类声明时通过一个标识表示类中某个属性的类型，或者时某个方法返回值的类型，或者时参数类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.*;

public class Test {
    public static void main(String[] args) {
        AA<String> aa=new AA<String>("HUAHAU");
        System.out.println(aa);
    }
}

class AA<E>{
    E s;

    public AA(E s) {
        this.s = s;
    }

    @Override
    public String toString() {
        return "AA{" +
                "s=" + s +
                '}';
    }
}

image-20220703174140109

泛型的语法

接口和类都可以拥有泛型，interface接口{},和class类<k,v>{},尖括号里面并不表示值，而是表示类型，常用T来表示，是Type的缩写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.*;

public class Test {
    public static void main(String[] args) {
        Student student=new Student("amin");
        Student student1=new Student("amin");
        System.out.println(student.hashCode());
        System.out.println(student1.hashCode());
        HashMap<String,Student> hashMap=new HashMap<String,Student>();
        hashMap.put(student.getName(), student);
        hashMap.put(student1.getName(), student1);

        for (String name: hashMap.keySet()){
            System.out.println(name+hashMap.get(name));
        }
        Set<Map.Entry<String,Student>> entries=hashMap.entrySet();
        Iterator<Map.Entry<String,Student>> iterator= entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String,Student>  next=  iterator.next();
            System.out.println(next.getKey()+next.getValue());
        }

    }
}

class Student{
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

image-20220703174210168

泛型的使用细节

  1. 在接口泛型或者类泛型的时候，T或者E只能是引用类型，不可以是基本数据类型
  2. 在指定泛型基本类型后，可以使用其子类的类型。B类继承了student类，那么我们也可以传入子类。!image-20220703174223853
  3. 在实际的开发中，编译器会进行类型推断，所以我们会进行简写，编译器会进行类型推断，比如：HashMap<String,Student> hashMap=new HashMap<>();
  4. 如果我们不使用泛型的<>,默认使用的Object的泛型。HashMap hashMap=new HashMap();也可以将比较方法进行封装

练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import java.util.*;

public class Test {
    public static void main(String[] args) {
        ArrayList<Employee> arrayList=new ArrayList<>();
        arrayList.add(new Employee("花花",563.23,new MyDate(2001,1,3)));
        arrayList.add(new Employee("鬼鬼",56375.23,new MyDate(2002,1,3)));
        arrayList.add(new Employee("花花",56355.23,new MyDate(2003,1,3)));
        System.out.println(arrayList);
        Collections.sort(arrayList, new Comparator<>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                int i=o1.getName().compareTo(o2.getName());
                if (i!=0){
                    return i;
                }
                else{
                    int j=o1.getBirthday().getYear()-o2.getBirthday().getYear();
                    if (j!=0){
                        return j;
                    }
                    else {
                        return o1.getBirthday().getMonth()-o2.getBirthday().getMonth();
                    }
                }

            }
        });
        System.out.println(arrayList);
    }
}

class  Employee{
    private String name;
    private double salary;
    private MyDate birthday;

    public Employee(String name, double salary, MyDate birthday) {
        this.name = name;
        this.salary = salary;
        this.birthday = birthday;
    }
    @Override
    public String toString(){
        return name+salary+birthday;
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public MyDate getBirthday() {
        return birthday;
    }
}
class MyDate{
    private  int year;
    private  int month;
    private  int day;

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

image-20220703173913177

发表于 更新于 分类于 ， Valine：

Java中基本数据类型赋值机制与数组的赋值机制

基本数据类型赋值

首先运行一下以下的代码，注意查看结果，可以发现n2的值并没有随着n1值给便而改变。

这种数据赋值方式为值拷贝！！！！，仅仅将数据的值拷贝走，并没有管理他的地址。

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        int n1=10;
        int n2=n1;
        n1=80;
        System.out.println(n1);
        System.out.println(n2);
    }
    }

image-20220331123443871

jvm内存结构包括栈，堆与方法区。下面来说一下原理，定义n1=10，其结果直接存储在jvm虚拟机的栈中，同样n2=n1，直接找到n1的对应的值，将10传值给n2。所以n1的改变不影响n2。

image-20220331123501223

数组类型的赋值

运行以下代码，数据的赋值类型为地址拷贝（引用赋值），即拷贝的是对应对象的地址。观察运行结果可以发现其两个数组的地址一模一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.Arrays;

public class Test {
    public static void main(String [] args){
        int []n1={10};
        int []n2=n1;
        n1[0]=80;
        System.out.println(Arrays.toString(n1));
        System.out.println(Arrays.toString(n2));
        //打印出他们的地址
        System.out.println(n1);
        System.out.println(n2);
    }
    }

image-20220331123534717

在数组赋值时候，栈中存放的为响应的地址，这也是为什么直接输出n1的时候是一个地址值，而n2数组取值时候接受到n1对应的地址，所以当n1改变时候，n2也会随着改变，这就是引用赋值。

image-20220331123609262

总结

看到这里学过c语言的小伙伴可以发现，这个其实和c的指针很像，是因为Java把c语言中的指针封装了，在Java中没有指针这一概念的。

发表于 更新于 分类于 ， Valine：

Java中整数型与浮点数等数据类型的使用细节

各类型所占大小

类型 字符数
byte 1字节
char 2字节
short 2字节
int 4字节
float 4字节
long 8字节
double 8字节
boolean 至少1字节

从Java7开始，加上前缀0b或者0B就可以写二进制数，0b1001表示9。

一个byte的值b可以不表示范围-128-127，如果表示0-255，也可以使用byte

下面的这种情况，没有出现我们期望的0.9，主要原因是浮点数采用二进制系统表示，在二进制系统中无法精确表示1/10，就好像十进制无法表示分数1/3一样。所以这种情况我们 使用大数表示。https://moonshuo.cn/posts/30946.html

image-20220606215246295

整数型

首先Java中默认的整数型为int数据类型，其取值范围为2^31-1——-2^31,而其中long类型的取值范围为2^63-1——-2^63,如果运行以下一段程序，会出现值损失的情况，是因为long表示的数据范围大于int可表示的数据范围，int的类型值存储不了long类型的值。

1
2
3
4
5
6
7
8
public class Test {
    public static void main(String [] args){
        int a=1;
        long b=2;
        a=b;
        System.out.println(a);
    }
}

image-20220331123731718

但是对于byte类型或者short类型的数据赋值给int类型，则其最终的类型为自动升级为更加高级的int类型

浮点型

浮点数=符号位+指数位+尾数位（尾数部分可能会包括不了全部的尾数，会造成精度损失，小数都是近似值），在浮点型中分为double型与float类型，而Java默认的使用double类型，如果想要使用float类型，必须在数的最后加上f，表示这是一个单精度浮点数，否则会发生值损失错误。运行以下程序，会发生信息报错。而如果在10.2后面加上f，则不会报错。

1
2
3
4
5
6
7
8
9
10
public class Test {
    /**这是算出函数类型的数据*/
    public static String getType(Object o){
        return o.getClass().toString();
    }
    public static void main(String [] args){
        float a=10.2;
        System.out.println(a);
    }
}

image-20220331123817168

image-20220331123847863

这是因为不加上f，表示double型的数据10.2赋值给float类型的a，由大转小会损失，而加上f之后，就是将float类型赋值给float类型，不会发生值损失。

浮点型科学计数法的表示，例如int a=5.12e2，表示5.12*(10^2)=512

1
2
3
4
5
6
7
8
9
10
public class Test {
    /**这是算出函数类型的数据*/
    public static String getType(Object o){
        return o.getClass().toString();
    }
    public static void main(String [] args){
        double a=5.12e2;
        System.out.println(a);
    }
}

image-20220331123904423

浮点型使用中常见的陷阱问题，从数学的角度来看，a与b应该完全相等的，但是计算机算出并不是相等，是因为计算机并不快速识别出8.1后面是否还有其他数值，所以计算机选择进行无限接近算出结果。所以并不建议用浮点型除法进行大小比较运算，如果真的要进行比较，通常在计算机中在某个精度范围内进行比较，不超过某个精度，即认为其相等。

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        double a=8.1/3;
        double b=2.7;
        System.out.println(a!=b?"a与b不相等":"a与b不想等");
        System.out.println(a);
        System.out.println(b);
    }
}

image-20220331123933887

字符类型

用单引号引出，并且其中只能包含一个字符，而对应的转义字符也表示一个字符，占据一个符号位，即char类型如果包含转义字符，就不能包含其他字符了。

1
2
3
4
5
6
7
8
public class Test {
    public static void main(String [] args){
       char a='哈';
       char b='\t';
        System.out.println(a);
        System.out.println(b);
    }
}

在Java中char的本质是一个整数，在输出时，是unicode对应的字符，例如a对应的字符编码为97，张的Unicode的对应的编码为24352，运行以下程序

1
2
3
4
5
6
7
8
9
10
11
public class Test {
    public static void main(String [] args){
       char a=97;
       char b='a';
       char c='张';
        System.out.println(a);
        //这里由于b的类型为char，输出响应的转义字符时需要进行强制类型转换
        System.out.println((int)b);
        System.out.println((int)c);
    }
}

布尔类型

布尔类型取值只允许取值为true与false，而且仅仅只占有一个字节。

发表于 更新于 分类于 ， Valine：

基本数据类型与String之间的转换

基本数据类型转换为String

利用拼接：String s=基本数据类型+” “；运行以下例子，查看结果可以发现仍旧为原来的数，只不过以String类型进行存储。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
    public static void main(String [] args){
        int a=100;
        double b=1.2;
        boolean c=true;
        String s1=a+"";
        String s2=b+"";
        String s3=c+"";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

image-20220331124055355

String转换为基本数据类型

通过基本数据类型的包装类调用parsexx的方法进行转换，运行以下例子，可以发现运行结果都会发生了转换，其他类型也都可以运用对应的包装类进行转换（char除外）。

1
2
3
4
5
6
7
8
public class Test {
    public static void main(String [] args){
        int a=Integer.parseInt("123");
        Double b=Double.parseDouble("1.2");
        System.out.println(a);
        System.out.println(b);
    }
}

image-20220331124131980

利用charAt将其转换为char，运行以下代码

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String [] args){
        String a="i love you";
        for (int i=0;i<a.length();i++){
            char s=a.charAt(i);
            System.out.print(s+"\t");

        }
    }
}

image-20220331124144789

注意事项

  1. 可以把“123”转换为一个int类型，但是“hello”就不可以转换为对应的类型，否则会发生异常，造成程序终止

发表于 更新于 分类于 ， Valine：

Java中自动类型转换与强制类型转换

自动类型转换

精度小的值自动转换为精度大的值的数据类型,下面我们看一下自动类型转换的两条线路

char->int->long->float->double

byte->short->int->long->float->double

实验以下下面的代码

1
2
3
4
5
6
7
8
9
10
11
public class Test {
    public static void main(String [] args){
        //令a的值为一个字符a的值
      int a='a';
      //输出的结果为该值对应的ASCII码
      System.out.println(a);
      //其实从某种意义上说，1为本质为byte类型的数据，而我们将其自动转换存储到int数据类型中
      int b=1;
      System.out.println(b);
    }
}

image-20220331124233303

自动数据类型转换注意细节

  1. 有多种数据类型混合运算时，系统首先将所有的数据转换成容量最大的那一种类型。
  2. 只能将小精度的类型赋值给大类型的数据，而不能将大精度类型赋值小精度。
  3. byte,short和char之间不会进行数据类型转换（编译器规定无法识别）。
  4. byte，short，char之间可以相互计算，但是在计算过程中结果为int类型，不可以用byte等类型变量接受结果。
  5. boolean类型不参与类型转换。

强制类型转换

自动转换的逆过程，将过程大的数据类型转换为容量小的数据类型。使用时要加上强制转换符号（），但是会造成精度降低或者溢出。

运行以下程序，仔细观察结果，可以发现发生了精度损失和溢出，当然这些也不一定会出现，当类型足够装下时其大小时，不会发生以上错误。

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        int i=(int)1.9;
        System.out.println(i);
        int j=196;
        byte k=(byte)j;
        System.out.println(k);
    }
}

image-20220331124318663

强制类型转换细节

  1. 数据精度大->小，需要进行强制类型转换。
  2. 强转类型只会对最近的操作数有效（即其遇到的第一个数），往往会使用小括号提高优先级。
  3. char类型可以保存int类型的常量值，但是不可以保存变量值（保存变量值时可能会发生损失）,需要进行强制类型转换。
1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String [] args){
        //如果强制转换类型对后面所有数据有效，则会输出29，如果仅仅对第一个类型有效，则结果为20
        int i=(int)2.9*10;
        System.out.println(i);
        char c1=100;
        System.out.println("c1保存了常量，可以保存，c1为"+c1);
        int  a=100;
        char c2=(char)a;
        System.out.println("强制转换之后，以ASCII码的形式进行保存，c2为"+c2);
    }
}

image-20220331124412290

发表于 更新于 分类于 ， Valine：

Java中控制结构

顺序控制

程序自上而下的执行，中间没有任何判断和跳转

观察以下两个程序，可以发现程序2违反了正常的逻辑规则，在未知的情况下num1的情况下就运行num2

1
2
3
4
5
6
7
public class Test {
    public static void main(String [] args){
        int num1=1;
        int num2=num1+1;
        System.out.println(num2);
    }
}

image-20220703175326334

1
2
3
4
5
6
7
public class Test {
    public static void main(String [] args){
        int num2=num1+1;
        int num1=1;
        System.out.println(num2);
    }
}

image-20220703175333923

分支控制（if-else与switch）

分支控制if-else（让程序有选择的执行）

单分支/双分支：

if（满足条件）{执行代码块，可以有多个语句}；else{执行代码块（不满足条件时）}

1
2
3
4
5
6
7
public class Test {
    public static void main(String [] args){
        int a=0;
        if (a==0){System.out.println("满足前面的表达式，a为0");}
        else{System.out.println("a不为0，不满足if表达式");}
    }
}

image-20220703175357742

多分枝：if ——else if——elseif……else

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        int a=2;
        if (a==0){System.out.println("满足前面的表达式，a为0");}
        else if(a==1){System.out.println("a=1");}
        else if(a==2){System.out.println("a=2");}
        else{System.out.println("a不为0，不满足if表达式");}
    }
}

image-20220703175420219

嵌套分支：if（表达式）{if（表达式）{};}——else,建议嵌套不要超过三层

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        int a=2;
        int b=3;
        if (a==2){if (b==3){System.out.println("a等于2，并且b等于3");}}
        else{System.out.println("ab其中一个不满足条件");}

    }
}

image-20220703175446129

Switch分支结构

用一个大家经常见到的例子来讲解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Scanner;
public class Test {
    public static void main(String [] args){
        Scanner testNumJudge=new Scanner(System.in);
        System.out.println("请输入您的成绩");
        int testNum=testNumJudge.nextInt();
        switch (testNum/10){
            case 9:System.out.println("你考的非常好");break;
            case 8:System.out.println("你考的不错");break;
            case 7:System.out.println("你考的还可以");break;
            case 6:System.out.println("你刚刚及格");break;
            default:System.out.println("准备补考吧，小伙子");
        }


    }
}

image-20220703175504436

循环控制结构

for循环控制结构

for（循环变量初始化；循环条件：循环变量迭代）{操作语句

}

1
2
3
4
5
6
7
public class Test {
    public static void main(String [] args){
        for(int i=0, k=1;i<10&k<11;i++,k++){
            System.out.println("我是i="+i+"\t我是k="+k);
        }
        }
    }

image-20220703175522530

while循环控制结构

while（循环条件）{循环体（语句）；循环变量迭代}

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        int i=0;int j=1;
        while(i<10&j<11){
            System.out.println("我是i="+i+"\t我是j="+j);
            i++;j++;
        }
        }
    }

image-20220703175534303

do while循环控制

do{循环体，循环迭代变量}while（循环条件），先循环一次在进行判断，一定会执行一次。看以下下面这个程序，发现根本不符合条件，但是还是执行了一次。

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String [] args){
        int i=0;int j=1;
        do {
            System.out.println("我是i="+i+"\t我是j="+j);
        }
        while(i<-1);

        }
    }

image-20220703175544737

多重循环控制

上述三种循环控制结构相互嵌套包含

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String [] args){
        for (int i=1;i<10;i++){
        System.out.println("我是i="+i);
            for (int j=1;j<=2;j++){
                System.out.println("我是第"+i+"个i下面的第"+j+"个j");
            }
        }
    }
    }

image-20220703175556772

break需求

结束这个循环，可以看出输出到5就不在进行输出了

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String [] args){
        for (int i=0;i<10;i++){
            System.out.println(i);
            if (i==5){
                break;
            }
        }
    }
    }

image-20220703175605105

continue需求

结束本次循环，可以看出本次循环中5并没有输出，直接跳出了本次循环

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String [] args){
        for (int i=0;i<10;i++){
            if (i==5){
              continue;
            }
            System.out.println(i);
        }
    }
    }

image-20220703175617131

利用循环结构打印出三种进阶的金字塔

难看的金字塔

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String [] args){
        for (int i=1;i<10;i=i+2){
            for (int j=0;j<i;j++){
            System.out.printf("*");}
            System.out.println();
        }
    }
    }

image-20220703175625783

真. 实心金字塔

1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String [] args){
        for (int i=1;i<10;i=i+2){
            for (int j=0;j<i;j++){
                for (int k=(10-i)/2;k>=0&j==0;k--){
                    System.out.printf(" ");
                }
                System.out.printf("*");}
            System.out.println();
        }
    }
    }

image-20220703175633525

真.空心金字塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {
    public static void main(String [] args){
        for (int i=1;i<10;i=i+2){
            for (int j=0;j<i;j++){
                for (int k=(10-i)/2;k>=0&j==0;k--){
                    System.out.printf(" ");
                }
                if (j==0|j==i-1|i==10-1){System.out.printf("*");}
                else {System.out.printf(" ");}
            }
            System.out.println();
        }
    }
    }

image-20220703175641159