java第二章节笔记

基本数据类型

数值型： 1字节8位

byte 1byte 1字节

short 2byte

int 4byte java中的整数字面量默认为int类型；0b开头的数值为二进制 0开头是八进制数 0x是16进制数；

long 8byte 在定义long类型的字面量，在字面量后加L；

浮点型

float 4字节 表示8位；因为浮点型十进制数转换为二进制数时，整数可以精确转换，而小数位，转换时因为表示的位数限制而发生进位，导致最终的数值不准确；

double 8字节

BigDecimal 精确定义的浮点型数据；

字符型

char 2字节，java中char类型，只能表示一个字符；

可进行算数运算，运算时，实际用的是此字符在编码表中对应的十进制编号。char字符用''应用。

编码表：

最早的 ASCII码表 包含英文字母和其他符号；

GBK 包含中文，英文字母；

java底层都采用Unicode编码表；国际上发明的一种较为全面的编码表。

后面的编码表都兼容了ASCII码的一部分。

计算机底层只能认识二进制数，不认字符，所以每个字符在底层编码表中都有一个对应的整数编码。

布尔型

boolean

只允许取值true/false，不可以用0或非0表示真/假；

基本数据类型的转换

1、8种基本数据类型：

byte stort int long 整型

float double 浮点型

char 字符型

boolean 布尔型

2、除过booolean外其他七种类型数据的转换

转换分类：

1.默认转换：

小容量类型转换成大容量类型（自动进行转换）

【4字节的float类型 容量大于8字节的long类型】（原因是小数和整数在底层底层二进制存储的计算方式不同）

2.强制转换：

大容量类型转换成小容量类型

可能会出现问题：

1.溢出。2.精度降低；

引用数据类型：

用系统中的类型做类型：如string，是java中的一个类；用string类表示一种类型；底层存储于c语言一致，用采用数组来存储多个字符。

string不能转成其他基本类型，运算只通过+连接；运算后只能是string类型。

运算符

不同类型的参与运算后，数据最终变成大的类型。

算数运算符号可对数值类型的数据，也可以对字符使用。

比较（或关系）运算符号作用比较单一，仅能对数值使用。（==||！=例外）

==和！=作用广，布尔型、引用类型，数值类型的比较均可使用。

逻辑运算符：逻辑值与逻辑值之间的运算；（即为符号两侧均为true/false）

&：逻辑与

&&：逻辑与（短路与）

区别：

单&符号当第一个表达式为false后，第二个表达式仍然执行；

双&&当第一个表达式为false后，第二个表达式不执行；

|：逻辑或

||：逻辑或（短路或）

区别：与&和&&同理；

单|符号当第一个表达式为true后，第二个表达式仍然执行；

双&&当第一个表达式为true后，第二个表达式不执行；

运行后的结果一致。

！：逻辑非（取反）

^：逻辑异或（同为真，异为假）

 public static void main(String[] args) {
        //运算符号
        int a=5;
        int b=10;
        int e=9;
        System.out.println(a+b);
        System.out.println("a+b="+a+b);
        System.out.println("--------------------------------");
        int c=++e;
        e =e+2;
        int f=e++;
        System.out.println(f);
        System.out.println(e);
        char g = 'A';
        char G = 'A';
        String h = "ABCD";
        System.out.println(h+a);//"+"作为连接作用；
        System.out.println("--------------------------------");
        //算数运算符号可以参与字符类型的加减运算
        //字符在底层运算过程中以数值类型参与
        System.out.println(g-G);
        System.out.println(g+G);
        System.out.println(g/G);
        System.out.println(g%G);
        System.out.println("--------------------------------");
        //==和！=可以参与多类型的运算，结果以布尔类型输出
        char i ='a';
        char j ='a';
        String k ="abcd";
        String l ="abcd";
        System.out.println(i==j);
        System.out.println(i!=j);
        System.out.println(k==l);
        System.out.println(k!=l);
        System.out.println("--------------------------------");
        //逻辑运算符号
        int A=10;
        int B=5;
        int C=1;
        // & ‘’&&逻辑与
        //&当第一个表达式为false后，第二个表达式仍然执行；
        System.out.println(A>B & C>A);//true & false ->false
        System.out.println(C>A & B++<A);//false & true ->false
        System.out.println(B);
        System.out.println(--B);//先进行--的运行，再输出B
        int D=10;
        System.out.println(D/=B);
        System.out.println(C<A & B<A);//true &true ->true
        System.out.println("--------------------------------");
        //&&当第一个表达式为false后，第二个表达式不执行；
        System.out.println(A>B && C>A);//true & false ->false
        System.out.println(C>A && B++<A);//false & true ->false;
        System.out.println(B);//B++不执行，所以B还是5；
        System.out.println(--B);//先进行--的运行，再输出
        D=10;//但B的值还没变
        System.out.println(D/=B);
        System.out.println(C<A && B<A);//true &true ->true
        System.out.println("--------------------------------");
        // |  ‘’||逻辑或
        // |当第一个表达式为true后，第二个表达式仍然执行；
        A = 10;
        B = 5;
        C = 1;
        System.out.println(A>B | C>A);//true | false ->true
        System.out.println(C>A | B++<A);//false | true ->ture
        System.out.println(C>A | B>A);//false | false ->false
        System.out.println(B);
        System.out.println("--------------------------------");
        // ||当第一个表达式为true后，第二个表达式不执行；运行结果一致。
        System.out.println(A>B || C++>A);//true | false ->true
        System.out.println(C>A || B<A);//false | true ->ture
        System.out.println(C>A || B>A);//false | false ->false
        System.out.println(C);
    }

赋值运算符:

赋值时，要注意左右两侧的数据类型是否一致，不同时要遵守数据类型转换时的规则。

各种运算符

 public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int c = 0;
        c += b;   //c=c+b;
        System.out.println(c);
        c -= a;   //c=c-a;
        System.out.println(c);
        c *= c;   //c=c*c;
        System.out.println(c);
        c /= b;   //c=c/b;
        System.out.println(c);
        a %= b;   //a=a%b;
        System.out.println(a);
    }

位运算符：

位是二进制的bit位；

”<<“左移 左移一位相当于 乘2

">>"右移 右移一位相当于 除以2（带符号位移） （高位移动后，正数补0，负数补1）

“>>>”无符号右移；（不带符号的位移）（高位移动后默认补0）

| 或 (a=4 0100 b=3 0011 a|b 0111)

& 与 (a=4 0000 b=3 0011 a&b 0000)

^ 异或 (a=4 0100 b=3 0011 a^b 0111)

这三个可以进行逻辑运算（左右都是逻辑值），也可进行位运算（数值）

~ 非 (a=4 0100 ~a=-5 1.... 1011 )

控制台输入

输入的方法：

通过Scannr类实现从控制台向程序的输入信息功能。

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

2.创建Scanner类的对象：Scanner  (你给定的名字) = new Scanner(System.in)

3.通过Scanner类的方法调用，获得所要类型的变量。

next() 获取String类的字符串；

nextInt() 整数类型；

next+ (开头字母大写的类型) +();

import java.util.Scanner;
public class inpot {
    public static void main(String[] args) {
        Scanner Scan =new Scanner(System.in);		//创建Scanner类型的对象。
        System.out.println("请输入姓名：");
        String name = Scan.next();					//输入String类型的字符串，名为name。
        System.out.println("请输入年龄:");
        int age = Scan.nextInt();					//输入int型的数据，名为age。
        System.out.println("姓名："+name+"年龄："+age);
    }
}

判断一只狗子相对于人的年龄

(狗子的前两年,每一年相当于人的10.5岁,之后每增加一岁 就增加4岁)

 其中通过一个for循环来判断是否去继续进行对狗子年龄的判断。

由于  for(); 的机制为for(初始化;布尔表达式;改变的值)；再对中间的布尔表达式进行影响，若布尔表达式的值为true，则继续进行循环，若为false则退出循环。

程序中通过 boolean 定义一个名为 chose 的布尔值，放在for循环中的布尔表达式的位置，通过输入 chose的值来影响for循环的进行。

import java.util.Scanner;
public class text {
    public static void main(String args[]) {
        Scanner Scan =new Scanner(System.in);
        boolean chose =true;
        for(;chose;)
        {
            Scanner scan =new Scanner(System.in);
            System.out.println("请输入狗狗的整数年龄:");
            int age1 = scan.nextInt();
            double age2 = 0.0;
            if(age1>0 | age1 ==0)
            {
                if(age1<2 | age1==0)
                {
                    age2 =10.5 * age1;
                    System.out.println("狗子的相对年龄为："+ age2+"\n");
                }
                else
                {
                    age2 = 21 + 4 * (age1-2);
                    System.out.println("狗子的相对年龄为："+ age2+"\n");
                }
            }
            else
            {
                System.out.println("请输入正确的年龄！\n");
            }
            System.out.println("---进行你的选择，继续还是退出。---");
            System.out.println("---true.继续-----false.退出---");
            System.out.println("-----------------------------");
            System.out.println("你的选择是：");
            chose = Scan.nextBoolean();
        }
        System.out.println("欢迎下次使用。");
    }

循环：

for while do while语句均支持

while循环

while(逻辑表达式/返还一个布尔值/){

循环体；

迭代部分；

}

do while循环

do{

先执行一次后，再判断；

}while（条件表达式）

for循环

for（变量初始语句；逻辑表达式--实为布尔值；变量的修改迭代语句）

for（表达式1；表达式2；表达式3）

{

语句；

}

或者

表达式1

for（；表达式2；）

{

语句；

表达式3；

}

三者均可执行死循环。

break&continue

break终止所在的那层整个循环；

continue终止本次循环；

循环嵌套：

将一个循环放入另一个循环中。

由于输出时:

for (int i=1;i<4;i++){//外循环
	for(int j=0;j<4;j++){//内循环
		System.out.print("*")
	}
    System.out.println();//做一个换行操作。
}
//内层循环中，结束外层循环
for (int i=1;i<5;i++){
	for(int j=0;j<5;j++){
        if(j==3)
        {
            break;//结束所在的那层循环
        }
		System.out.println("j")
	}
    System.out,println("i");
}
//在内循环中，结束外循环   需要再想结束的循环外面加一个标签或名称。
out:for (int i=1;i<5;i++){//给外循环命名为out；
	for(int j=0;j<5;j++){
        if(j==3)
        {
            break out;//结束名为out的循环
        }
		System.out.println("j")
	}
    System.out,println("i");
}

print()不会自动换行。

println()会自动换行。

java中的的方法：

java中的的方法方法类似其他语言中的函数,将某个功能的代码封装，并命名。

便于重复调用。（方法必须写在.java文件中）

public（访问权限）默认+static 以此开头

此方法没返回值时+void

static 静态的 可以直接使用类名调用

menu 方法名。