java第二天学习总结2

46 阅读 0 评论 31 点赞

我是靠谱客的博主热情巨人，最近开发中收集的这篇文章主要介绍java第二天学习总结2，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

存储单位

bit : 比特,一个比特就是一个电子位,统称位

byte : 字节 = 8bit

short : 短整型 = 16bit

int : 整型 = 32bit

long : 长整型 = 64bit

ASCII码

A : 65 //这些要记住

B : 66

a : 97

b : 98

0 : 48

1 : 49

数据类型分类

本质 : 规定占用内存空间的大小,用位和字节表示

分类 :
*        基本数据类型
*            数值型
*                整数型
*                    byte 字节 8bit
*                    short 短整型 16bit
*                    int 整型 32bit
*                    long 长整型 64bit
*                浮点型
*                    float 单浮点 32bit
*                    double 双浮点 64bit
*            字符型
*                char 字符 16bit
*            布尔型
*                boolean 8bit
*        引用数据类型
*            类,数组,接口

java中表示八进制
*        int i = 011;
*
* java中表示十六进制
*        int i = 0x11;
*        0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f
*
* java中没有办法直接表示二进制

INT

public class DT_01_Int {
   public static void main(String[] args){
       // 用int类型,划分了一个32位的空间大小,并给空间命名为 i_1 ,然后把10放进去
       int i_1 = 10;
       int i_2 = 010;
       int i_3 = 0x10;
       // 通过名字,找到对应空间的数据,并打印
       System.out.println(i_1);
       System.out.println(i_2);
       System.out.println(i_3);
       // java 中默认的整数是整型(int)
       System.out.println(2147483647);

       byte b_1 = -128;
       int i_4 = 2147483647;
       System.out.println(i_4);

       // long的值必须加L或者l 不区分大小写.建议大写,因为小写的l和1容易混淆
       // l_1 = 123; 没问题,因为123默认是int类型,而long类型大于int类型,所以可以自动转换
       long l_1 = 123;
       // 加 L/l 之后就不会转换,因为这个值就是long类型的值
       long l_2 = 9223372036854775807L;
       // 9223372036854775807
       System.out.println(Long.MAX_VALUE);
   }
}

DOUBLE

package _01_DataType;

/**
* float : 32bit
*
* double : 64bit
*
* java中默认的小数是double
*
*
*/
public class DT_02_Double {

   public static void main(String[] args) {
       double b1 = 1.2;
       // 默认double类型
       System.out.println(1.4);
       // float类型的值,必须加F/f
       float f1 = 1.2f;
       //
       System.out.println(b1);
       System.out.println(f1);
   }
}

CHAR

package _01_DataType;

/**
* 字符型 char, 16bit,用单引号表示
*
* java中的字符型采用unicode编码
*
* short : -32768 ~ 32767
*
* char : 0~65535 因为字符不需要负数
*
* 字符是文字和计算机存储转换的一种规则
*        a:97
*        A:65
*        0:48
*
*
*/
public class DT_03_Char {
   public static void main(String[] args) {
       // 注意单引号中只能有一个字符,空格也算
       char c_1 = ' ';
       // 把字符的值转换为整数
       int i_1 = c_1;
       System.out.println(i_1);
   }
}

BOOLEAN

package _01_DataType;
/**
* boolean 布尔型 : true/false
* 适用于流程控制
* 布尔型不参与任何类型转换
* 占用1字节,8bit , 全是0 表示false,0000 0001表示true
*
*
*/
public class DT_05_Boolean {

   public static void main(String[] args) {
       boolean flag = true;
       if (flag) {
           System.out.println("是真的");
       }else{
           System.out.println("是假的");
       }
   }
}

精度转换

package _01_DataType;

/**
* 八种基本数据类型中,除了布尔类型都是可以任意转换
*            自动类型转换 : 低精度到高精度
*            强制类型转换 : 高精度到低精度(有可能损失精度)
*                低精度类型 = (低精度类型) 高精度值;
*                byte b1 = (byte) i1;
*        byte ,short , int , long ,float , double
*                char
*
*
*/
public class DT_07_DataChange {
   public static void main(String[] args) {
       byte b1 = 125;
       short s1 = b1;
       int i1 = s1;
       long l1 = i1;
       float f1 = l1;
       double d1 = f1;

       // char c1 = b1;
       // char c2 = s1;
       char c = 'a';
       // short s2 = c;
       int i2 = c;

       int i3 = 97;
       char c3 = (char) i3;
       System.out.println(c3);

       int i4 = 123;
       byte b2 = (byte) i4;
       // 123 因为把int的123 转换为byte之后,依然可以存储的
       System.out.println(b2);

       // --------------------------
       // 如果多种数据类型进行混合运算,那么结果的类型一定是运算中出现的最大的类型
       long i_1 = b1+s1+i1+l1;
       // 但是 byte , short , int , char 四种类型,任意一种或多种进行运算,结构都是int类型
       int s_1 = b1+s1;
       int b_1 = b1+b1;
   }
}

小总结：Java中默认是int

long的值必须加L/l，加上之后，就不会转变为int；

double b=1.2；默认为double

float类型的值必须加F/f

char为 16bit，用单引号表示 short也是16bit，和short为平行关系，但是char不能在精度转换是使用

short：-32768 ~ 32767

char : 0~65535 因为字符不需要负数

Java中的字符型用unicode编码表示

// char 默认值是 u0000
char c_3 = 'u4e2d';
System.out.println(c_3);

boolean

布尔型不参与任何类型转换，占用1字节,8bit , 全是0 表示false,0000 0001表示true

boolean flag = true;
       if (flag) {
           System.out.println("是真的");
       }else{
           System.out.println("是假的");
       }

自动类型转换 : 低精度到高精度
* 强制类型转换 : 高精度到低精度(有可能损失精度)
* 低精度类型 = (低精度类型) 高精度值;

// char c1 = b1;
       // char c2 = s1;
       char c = 'a';
       // short s2 = c;
       int i2 = c;

       int i3 = 97;
       char c3 = (char) i3;
       System.out.println(c3);

int i4 = 123;
       byte b2 = (byte) i4;
       // 123 因为把int的123 转换为byte之后,依然可以存储的
       System.out.println(b2);

long i_1 = b1+s1+i1+l1;
// 但是 byte , short , int , char 四种类型,任意一种或多种进行运算,结构都是int类型

负数存储补码

-128 ~ 127

常量 / 字面量 : 整个生命周期中值不可更改

变量

*        字面量 : 直接写,不声明空间存储
*        常量 : final声明,值不可更改
*
* 变量 : 可以更改的数据,有名字的内存空间
*
* 变量可以做到内存空间的复用
*
* 变量声明 :
*        数据类型变量名 = 值;
*        int i = 10;
*
* 同时声明多个变量
*        int a,b,c; 声明并不赋值
*        int a =1 , b = 2, c=3; 声明并赋值
*
* 全局变量 :
*        什么是全局变量 : 允许在类之外创建变量,和类同级别,那么所有类都可以直接访问这个变量,不需要二次引用
*            二次引用 : 就是没有使用 . 这个操作符 xxx.age;
*        首先java中不允许这个变量创建在类之外,但是可以将一个变量设置为public,公共的,那么其他类也就可以使用这个变量
*            但是必须要使用 . 来使用,并不是直接使用
*
*        全局变量缺点 : 安全性差,容易命名冲突
*
* 根据变量的声明位置,变量被分为了三类
*        域 : 写的这个变量,能在哪里用,就是使用范围,一般称为作用域
*            一个 {} 就是一个作用域,变量的作用范围,不会超过向上包含它的第一个大括号
*
*
*        成员变量 : 类体中,没有static修饰的变量
*        静态变量 : 类体中,使用static修饰的变量
*        局部变量 : 方法中声明的变量
*
* 变量的调用 :
*        局部变量 : 当前方法中,直接写变量名调用
*        静态变量 : 类名.静态变量名 , 调用当前类中的静态变量,类名可以省略
*        成员变量 : 对象.成员变量名
*

// 静态变量
   static int a = 2;
   // 成员变量
   int b = 3;

public static void main(String[] args) {
       System.out.println(10);
       System.out.println(10);
       System.out.println(10);
       // 局部变量
       int i = 10;
       i = 11;
       if (true) {
           int b = 2;
           System.out.println(b);
           System.out.println(i);
       }
       // System.out.println(b);
       System.out.println(i);
       System.out.println(i);
       System.out.println(i);
       // 类名.静态变量名
       System.out.println(Var_01.a); //文件名.类
       System.out.println(a);
   }

局部变量没有默认值,必须先赋值,后使用
*
* 静态/成员变量,有默认值
*            整型 : 0
*            浮点型 : 0.0
*            字符型 : u0000
*            布尔型 : false
*            引用类型 : null

public class Var_02 {
   // 静态变量
   static int b ;
   public static void main(String[] args) {
       // 局部变量
       int a = 1;
       // 调用局部变量
       System.out.println(a);
       // 调用静态变量
       System.out.println(Var_02.b);
       // 调用当前类的静态变量,类名可以省略
       System.out.println(b);
   }
}

变量可以同名吗?
*        静态变量和成员变量不能同名
*        但是局部变量可以和静态/成员变量同名
*        也就是说创建了一个局部变量 i , 还可以创建一个静态/成员变量i

public class Var_03 {
   static int i = 11;
   static int a = 10;
   public static void main(String[] args) {
       int b = 20;
       int i = 2;
       // 同作用域不允许同名
       // int i = 3;
       // 局部变量
       System.out.println(b);
       // 静态变量
       System.out.println(a);
       // 局部变量优先级大于静态/成员变量 //就是优先使用里面的变量
       System.out.println(i);
       // 使用类名区分同名的局部变量和静态变量
       System.out.println(Var_03.i);
   }
   public static void m1() {
       int i = 2;
       // 同作用域不允许同名
       // int i = 3;
   }
}

package _02_Var;

public class Var_04 {
   public static void main(String[] args) {
       // 字面量
       // int字面量
       System.out.println(10);
       // 布尔型字面量
       System.out.println(false);
       // double型字面量
       System.out.println(2.3);

       // 常量加final修饰
       final   int i = 10;
       // 加final修饰之后值不可更改
       // i = 20;
       // i = 30;
       System.out.println(i);
   }
}

优先级

*        单目运算符 > 双目 > 三目
*        i++ : 只有一个操作数 i 就是单目
*        i+b : 两个操作数 , i和b 就是双目

关系运算符 : 返回的都是boolean类型(true/false)
*
* > , >= , < , <=
*
* == : 判断两个值是否相等,
*        如果是基本类型则比较数值大小,
*        如果是引用类型则比较内存地址
*
* != : 不等于

public static void main(String[] args) {
       // 两边如果是整型,结果不会大于两个数中最小的一个
       // 一般用于计算数组下标
       // 先把两个数转换为对应的二进制,然后每位比较,都是1 就取1 ,否则就取0
       System.out.println(9 & 3);
       // true
       System.out.println(1 < 2 & 5 > 4);
       // true
       System.out.println(1 < 2 | 5 > 4);
       // false
       System.out.println( ! (1<2) );
       // false
       System.out.println(true ^ true);

       int a1 = 9;
       int b1 = 10;
       System.out.println(a1 == b1 && a1 > b1++);
       // 10 因为第一个条件为false,此时第二个条件不执行,也就是说 b1++ 不执行
       System.out.println(b1);
   }
}