JavaSE基础第二章笔记

不爱吃杨桃

已于 2024-01-06 21:44:24 修改

阅读量470

点赞数 8

文章标签： java 数据结构开发语言

于 2023-12-28 16:39:54 首次发布

本文链接：https://blog.csdn.net/2301_77681226/article/details/135253296

版权

一、Java数据类型

1.基本数据类型

整数类型byte ，short ，int ，long

字符型char

浮点类型float ，double

布尔型boolean

2.引用数据类型

用系统中的类作为类型，结构复杂，例如：String

这里引用数据类型没有细讲，具体将在之后进行讲解

数据类型String

属于引用数据类型

使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。

是Java库中提供的一个类，用类来当作字符串变量类型。

运算规则

1.任意八种基本数据类型的数据与String类型只能进行连接"+"运算，且结果一定也是String类型

2.String类型不能转为其他的基本类型

注意

boolean类型数据只允许取值true或false

定义float的数据时需要在后缀加f或F

字符型char占两个字节

在Java中，对char类型字符运行时，直接当作对应编码表的整数来对待。

二、基本数据类型转换

在Java程序中，不同的基本数据类型(这里只有7种，不包含boolean类型)变量的值经常需要进行相互转换。

1.默认转换

转换规则：将容量小的类型转换为容量大的类型，可以直接转换

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

这里4个字节的float的容量大于8个字节的long的容量，原因是float的小数和整数在底层的二进制存储计算方式不同

2、强制转换

转换规则：将容量大的类型转换为容量小的类型，需要添加强制转换符，例如：

int b = 10;
byte a = (byte)b;

当进行强制转换时，会出现的问题：

1.精确度变小了

float x = 20.25f;
int y = (int)x;
System.out.println(y);

2.溢出了

int m = 10;
byte n = (byte)m;
System.out.println(n);

字节大小容量不足

注意

有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那种数据类型，然后再进行计算。

三、运算符

在Java语言中支持如下运算符：

1.算术运算符

"+"号的用法有三种表示数与数之间的相加：

int a = 5;
int b = 10;
System.out.println(a+b);

表示数值的正负：+3

表示数与字符串的连接:

int a = 10;
System.out.println("a="+a);//数值与字符串之间的连接

String b = "ab";
String c = "cd";
System.out.println(b+c);//字符串与字符串之间的连接

"-"号与"+"号的区别在于不作为字符串与字符串，数值与字符串之间的连接

"*","/"作为数与数之间的计算中，但需要注意优先级

++，--

int a1 = 10;
a1+=a1++;//先取值，后运算
System.out.println(a1);

int a2 = 10;
a2+=++a2;//先运算，后取值
System.out.println(a2);

2、比较运算符

比较运算符的结果都是boolean型，也就是要么是true，要么是false

注意：比较运算符中"=="不能误写成"="。

3、逻辑运算符

& 逻辑与 | 逻辑或 ! 逻辑非

&& 逻辑与(短路与) || 逻辑或(短路或) ^ 逻辑异或

        int a = 5;
        int b = 10;
        int x = 15;
        int y = 20;
        System.out.println(a<b & x<y);//true & ture --> true
        System.out.println(a<b & x>y);//true & false--> false
        System.out.println(a>b & x>++y);//false & false--> false
        System.out.println(y);

        System.out.println("--------------------------------");

        // && 双逻辑与
        //左边为真，右边参与运算，左边为假，右边不参与运算
        System.out.println(a<b && x<y);//true & ture --> true
        System.out.println(a<b && x>y);//true & false--> false
        System.out.println(a>b && ++x>y);//false & false--> false
        System.out.println(y);

        System.out.println("\n");

        // | 单逻辑或  两边有一为真，结果为真
        //左边无论真假，右边都将进行运算
        System.out.println(a<b & x<y);//true & ture --> true
        System.out.println(a<b & x>++y);//true & false--> false
        System.out.println(a>b & x>y);//false & false--> false
        System.out.println(y);

        System.out.println("--------------------------------");

        // || 双逻辑或
        //左边为真，右边不参与运算，左边为假，右边参与运算
        System.out.println(a<b & x<y);//true & ture --> true
        System.out.println(a<b & x>++y);//true & false--> false
        System.out.println(a>b & x>y);//false & false--> false
        System.out.println(y);

        System.out.println("\n");

        // ! 逻辑非
        System.out.println(x>y);//false
        System.out.println(!(x>y));//true

        System.out.println("--------------------------------");

        // ^ 逻辑异或
        //两边相等为假，两边不等为真
        System.out.println(x>y ^ a<b);//false true --> true
        System.out.println(x<y ^ a<b);//true  true --> false

4、赋值运算符

通过符号"="进行操作

当"="两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

所以需要注意强制转换导致的误差，例如：

   short s = 3;//int --> short
   //如果表示为s=s+2  short = short + int ,会出现int类型转换成short类型，所以会出现报错
   s+=2;

        int i = 1;
        i *= 0.1;
        System.out.println(i);//0  输出时出现取整

扩展赋值运算符： +=，-=，*=，/=，%=

5、条件运算符

语法：(条件表达式)？表达式1：表达式2;

如上图：当条件表达式为真时，运算输出的结果是表达式1；当条件表达式为假，运算输出的结果是表达式2。

如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

例如：

       int a = 60;
       String result = (a>=60)?"及格":"不及格";
       //这里条件运算符的返回值为true或者false，所以"及格""比不及格"都是字符串，类型相同
       System.out.println(result);

6、位运算符

用于优化算法，减小运行开销

对位运算符的解释

位: 二进制的bit位

<<左移移一位相当于给数乘2

>>右移移一位相当于给数除2

>>>无符号右移

& | ^ 可以进行逻辑运算(左右两边是逻辑值)，也可以进行位运算(数值)

        int a = -8;
        //1000  -8
        a = a>>1;
        //1111 ... 1100  -4
        System.out.println(a);
        a = a<<1;
        //1111 ... 0000  -8
        System.out.println(a);

        //无符号右移
        int b = -8;
        b = b>>>1;
        //0111 ... 1100   2147483644
        System.out.println(b);

        int m = 3;
        int n = 4;
        //0011   3
        //0100   4
        System.out.println(m&n);//  0
        System.out.println(m|n);//  7
        System.out.println(m^n);//  8
        System.out.println(~m);//  -4

其中需注意无符号移动的特殊性会导致所输出的数出现很大的区别

控制台输入

Java提供Scanner类来实现从控制台向程序输入信息功能。

具体步骤：

1. 导入使用的类：import java.util.Scanner;

2. 创建Scanner类型的对象：Scanner scan = new Scanner(System.in);

3. 调用Scanner类的相关方法,来获取指定类型的变量

next()方法用以取得用户输入的字符串；

nextInt()将取得的输入字符串转换为整数类型；

nextFloat()转换成浮点型；

nextBoolean()转换成布尔型。

例如：

 import java.util.Scanner;//导入使用的类

public class Demo12 {
    public static void main(String[] args) {
        //创建一个能够输入的对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名称");
        String name = scanner.next();//读入控制台输入的类型   next()返回字符串

        System.out.println("请输入年龄");
        int age = scanner.nextInt();//读入控制台输入的年龄    nextInt()返回整数
        System.out.println("姓名"+name+"年龄"+age);


    }

}

四、控制语句

1、条件语句

根据不同条件，执行不同语句

if else

if else if

if .. else if .. else if .. else

if语句的四种基本应用

if(条件表达式，最后返回一个boolean值){}

if(条件表达式，最后返回一个boolean值){
}else if(条件表达式，最后返回一个boolean值)

if(条件表达式，最后返回一个boolean值){
}else if(条件表达式，最后返回一个boolean值){
}else{}

if/else/for 语句后就算只有一行代码，最好加上一个{}  避免歧义

代码实现：

    public static void main(String[] args) {
        int w = 3;
        if (w>=3)
            System.out.println("成立1");//不加{}if只能控制离他最近的一行代码
            System.out.println("成立2");//不在if的可控范围内

        if (w==1){

        }else if (w==2){

        }else if (w==3){

        }
    }

swtich

switch语句的基本应用

switch语句
switch(表达式){
case value1: 语句序列1;
  [break];
  ......
case valueN:语句序列N;
  [break];
  [default:  缺省语句;]

代码实现：


        String  week = "3";

        switch (week){
            case "1" :
                System.out.println(1);
                break;
            case "2" :
                System.out.println(2);
                break;
            case "3":
                System.out.println(3);
            case "4":
                System.out.println(4);
                break;
            case "5":
                System.out.println(4);
                break;
            default:
                System.out.println("输入错误");
        }

2、循环语句

重复执行某些动作

for

for语句的基本应用

for(表达式1; 表达式2; 表达式3){ 语句; … ; }

代码实现：

        for (int i=0;i<5;i++){
            System.out.println(i);
        }

还可以写为以下两种形式

for (;i<5;i++){
            System.out.println(i);
        }
        System.out.println(i);

int i=0;
        for (;i<5;){
            System.out.println(i);
            i++;
        }
        System.out.println(i);

运行结果都相同

for循环也可以实现死循环

代码实现：

        for(;;){
            System.out.println(1);
        }

while

while语句的基本应用

//初始化部分
while(逻辑表达式){
    循环体
    迭代部分
}

执行过程中
  会先判断逻辑表达式的值
  若=true 则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立为止

代码实现：

         int a = 0;
         while (a<5){
             System.out.println(a);
             a++;
         }

while语句的死循环的实现

注意while后的（）中只能输入true或false，不能输入1或0，这是Java于c语言的区别

        while (true){
            System.out.println(1);
        }

do while;

do{
循环体
}while(逻辑表达式);

执行过程

先执行语句，再判断逻辑表达式的值，若为true，再执行语句，否则结束循环。

代码实现：

        int a;
        do{
            System.out.println("请输入一个整数");
            Scanner scanner = new Scanner(System.in);
            a = scanner.nextInt();
        }while (a==10);

1、三种循环的对比

三种循环结构都具有四个要素：

循环变量的初始化条件

循环条件

循环体语句块

循环变量的修改的迭代表达式

1、从循环次数角度分析

do-while循环至少执行一次循环体语句。

for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。

2、如何选择

遍历有明显的循环次数（范围）的需求，选择for循环

遍历没有明显的循环次数（范围）的需求，选择while循环

如果循环体语句块至少执行一次，可以考虑使用do-while循环

本质上：三种循环之间完全可以互相转换，都能实现循环的功能

break与continue

break 语句用于终止某个语句块的执行。用在

循环语句体中，可以强行退出循环；例如：

        int stop = 4;
        for (int i = 1; i <= 10; i++) {
        //当i等于stop时，退出循环
            if (i == stop){
                break;
            }
            System.out.println(" i= " + i);
        }

continue 语句用在循环语句体中，用于终止某

次循环过程，跳过循环体中 continue 语句下

面未执行的循环，开始下一次循环过程；例

如：

        int skip = 4;
        for (int i = 1; i <= 5; i++) {
        //当i等于skip时，跳过当次循环
            if (i == skip){
                continue;
            }

循环嵌套

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，

for ,while ,do…while均可以作为外层循环和内层循环。

实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层

循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当

次循环，开始下一次的循环。

例如：

            for (int i = 0; i < 4; i++) {//外层循环
            for (int j = 0; j < 4; j++) {//内存循环
                System.out.print("*");
            }
             System.out.println();//换行
        }

结束外层循环

如果需要从多层循环跳出，则需要使用标签，定义一个标签,如label，

然后在需要跳出的地方，用break label就行了.

例如：

        out:for (int i = 0; i <5 ; i++) {
             for (int j = 0; j < 5; j++) {
                if(j==3){
                    break out; 
    //break只能结束所在的那一层循环,不能结束外层循环    break 标签名(循环名字)
                }
                System.out.println("j=="+j);
             }
            System.out.println("i=="+i);
        }

这里需要注意println与printf之间的区别

println会自动换行

print不会自动换行


        System.out.println("*");    //println() 会自动换行
        System.out.println("*");
        System.out.println("*");
        System.out.print("a");
        System.out.print("a");
        System.out.print("a");  //print() 不会自动换行

五、Java中的方法

Java中的方法类似于其它语言的函数，方法是解决一类问题步骤的组合,表示一种功能和行为.

将功能封装为方法的目的是，可以`实现代码重用，减少冗余，简化代码`

Java里的方法`不能独立存在`，所有的方法必须定义在类里(.java文件中)。

方法声明格式

[访问权限修饰符修饰符…] [返回值类型] 方法名(形式参数类型参数名){

Java语句；… … …

[return 返回值;]

}

例如：

    /*
    方法定义:
        public  访问权限
        static  静态的  直接可以使用类名调用
        void    表示此方法没有返回值
        menu    方法名
        ()      参数列表
        { }     方法体
     */
    public static void menu(){
        System.out.println("--------家庭收支记账软件--------");
        System.out.println("1.收支明细");
        System.out.println("2.登记收入");
        System.out.println("3.登记支出");
        System.out.println("4.退出");
    }

Java语言中使用下述形式调用方法：

类名/对象名.方法名(实参列表)

实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配，

return 语句终止方法的运行并指定要返回的数据。

return语句

return语句用于从当前执行的方法中退出, 返回到调用该方法的语句处继续执行。

    //java入口  固定格式
    public static void main(String[] args) {
//menu为上方代码中的方法
    Demo7.menu();//调用方法
        int n = 10;//注意类型之间的转换
    Demo7.print(n,10);
    int max = Demo7.max(6,16);//实参  是调用时传入的数据
        System.out.println(max);
    }



 public static int max(int a,int b) {
        return (a>b)?a:b;
    }



    public static void print(int num,int b) {
        if(num<=0){
            return;
//return 也可以在没有返回值的方法中使用，表示终止方法运行，但是return后面不能有任何的表达式
        }

有两种格式:

return 值; //将值返回,方法必须声明有返回值

上方的代码中max方法是有返回值的。

return; //不返回任何值，表示终止方法执行,可以在声明为void的方法中使用

print方法是没有返回值的。