2、类型和运算

1、常量和变量

　　常量：程序执行中，值不可以改变的量。

　　　　　分类:　 字面值常量：字面上写定了值.

　　　　 　　 　　自定义常量： final 的变量　　　　　　　　

　　　　　　　　

/*
    常量--程序执行中值不可以变
    字面值常量--写定了值
*/
public class ConstDemo
{
    //main方法是程序的入口
    public static void main(String[] args)
    {    
        //直接写名了值
        System.out.println(110);
        System.out.println(3.14);
        System.out.println('1');
        //字符,('')单引号之间只能是单个符号;注意('')是错误的,而(' ')是正确的
    }
}

　　变量:程序执行中,在某个范围内值可以改变的量.

　　　　 定义:　

　　　　　　　　方法1 先声明后赋值

　　　　　　　　方法2 在声明的同时赋值

　　　　作用:　  不断存放的某一类型的常量,并可以重复使用.

　　　　过程描述:

　　　　　　　　1)声明变量向内存申请一块空间,同时指定这块空间的名称(变量)和数据类型;

　　　　　　　　2)不断存放在这个类型中的常量.

　　　　分类(按作用域划分):

　　　　　　　　成员变量:直接定义在类中.

　　　　　　　　局部变量:出成员变量外的都是,(包括:方法形参\代码块变\方法内变量)

　　　　　　      作用域:只在这个区域内才能使用变量;从定义开始到定义所在的花括号结束.

　　　　使用规则:1)使用前,必须赋值.

　　　　　　　　 2)同一作用域中不能重复定义.　　　　 　

 　　　　　　　　

public class VarDemo
{
    public test = 20;//成员变量
    public static void main(String[] args)
    {
        //定义变量:方式1:先声明后附值
        byte a ;
        a = 10;
        byte a1,a2,a3; //也可以声明多个
        //定义变量:方式2:声明同时附值
        int b = 20;
        System.out.println(b);
    }
}

 　　　　　　　　

/*变量-注意事项*/
public class VarDemo2
{
    public static void main(String[] args)
    {    
        int v =10;//局部变量
        //byte v = 20;//报错:同一作用域,不能重复定义
        int c;
        //System.out.println(c);//变量使用前,必须赋值
    }
    byte test = 10;//成员变量
}

　　　　

2、数据类型

　　分类:

　　　　1)基本数据类型:

　　　　　　　　　　　整型: byte  占用1个字节　　-128到127

　　　　　　　　　　　　　  short  占用2个字节　　-32768到32767

　　　　　　　　　　　　　   int　　占用4个字节　　2^32次方

　　　　　　　　　　　　　　long　　占用8个字节　　2^64次方

　　   　　　　　　　　字符型:char　　占用2个字节  　　0到65535

　　　　　　　　　　　布尔型:boolen　　理论上占用8分之1个字节,但java中没有明确指明大小.

　　　　　　　　　　　浮点型: float　　占用4个字节

　　　　　　　　　　　　　　 double 　　占用8个字节

　　　　　　　　

/*布尔型*/
public class BooleanDemo1
{
    public static void main(String[] args)
    {    //布尔型常量
        System.out.println(true); 
        System.out.println(false);
        //布尔型变量
        boolean IsMan = true;
        System.out.println(IsMan);    
    }
}

　　　　　　　

　　　　　　　　

//整型(byte short int long)
public class BooleanDemo2
{
    public static void main(String[] args)
    {
        //二进制:前面加0b或0B
        System.out.println(0b1100100);
        //八进制:前面加0
        System.out.println(0144);
        //十六进制:前面加0x或0X
        System.out.println(0x64);
        //十进制:
        System.out.println(100);
    //注意:整数的默认类型是int,
    //操作的常量值超过int范围(及long类型),要指定l或L        
        long a = 888888888888L;
        //long a = 888888888888;//这里报错
        System.out.println(a);
    }
}

　

　　　　　　　　

public class DecimalDemo
{
    public static void main(String[] args)
    {
        /*小数常量:
                方式1:小数
                方式2:科学计数法
            小数默认是double类型;要表示常量为float要加上f或F
        */
        System.out.println(3.14);
        System.out.println(3.14E-2);
        System.out.println(3.14E2);
        //小数变量:
        float a =3.14F;
        System.out.println(a);
    }
}

　　　　　

　　　　　　　　

public class CharDemo
{    /*char类型:
            无符号整型
            unicode字符
    */
    public static void main(String[] args)
    {
    //常量:
        System.out.println('◆');
        System.out.println('7');

    //变量:输入无符号整型或unicode字符,返回unicode字符
        char t1 = 97;
        char t2 = '\u0061';
        char t3 = '码';
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t3);
    }
}

　　2)引用数据类型:

　　　　　　　　　类 接口 数组(基本数据类型以外的都是--引用数据类型)　　　　

　　　　　　　常用的引用数据类型:sting类;

　　　　　　　　引用数据类型默认值null

　　　　　　　　字符串通过+符号,将字符连接起来;用""号括起来;

　　　　　　　　任何类型和string相连接+,结构都是新的字符串　

　　　　　　　　

//做常用的引用类型:string
public class StringDemo
{
    public static void main(String[] args)
    {
        String username = "liang";
        System.out.println(username + 17);
        //转义字符
        System.out.println("\"师姐你好\"");
        String a = "haha";
        int b = a; //不兼容的类型: String无法转换为int
    }
}

　　　　　　　　　　　　　

3、基本数据类型转换

　　1)数据过大溢出

　　　　原因:变量存储的值,超出变量类型的容量　　　　　

　　　　　　　　

//要存储的值,超出变量类型的容量时,称为溢出
//int类型的范围:[-2147483648,2147483647]
public class  IntDemo
{
    public static void main(String[] args)
    {
        int max = 2147483647;
        max = max + 1;
        System.out.println(max);//-2147483648

        int mix = -2147483648;
         mix = mix - 1;
         System.out.println(mix);//2147483647
    }
}

　　2)基本数据类型转换

　　　boolean不是数值型,不参与转换

　　分类:1)强制类型转换(显式的转换)

　　　　　　　　可能会溢出或损失精度.

　　　　 2)自动类型转换(隐式的转换)

　　　　　　

　　3)表达式中类型的自动转换

　　　　　所有byte short char参与运算,自动转换为int

　　　　  最终的结果类型是表达式中容量最高的类型

　　　　  任何类型与string相连结果都是string.

4、运算符

　　4.1)算术运算符:

　　　　+号:2个字符相加得到是ASCII码表值;当2个字符串相加得到新字符串.

　　　　除号:任何整数除以0,会报错.

　　　　NaN:0.0/0.0 不是一个数;它自己不等于自己

　　自增/自减:将变量的值自增1/自减1

　　前自增:将变量值增1,再进行其他运算

　　后自增:将变量值增1,后拿变量原来的值,进行其他运算　　

　　注意:byte a ; a++ 相当于 a = a + 1,但是为什么没报错,java内部进行了转换a = (byte)(a+1);

　　　　　　

public class zizeng
{
    public static void main(String[] args)
    {    //自增自减
        //demo1:
        int num1 = 1;
        num1 = num1 ++;
        System.out.println(num1);//1
        int num2 = 1;
        num2 = ++ num2;
        System.out.println(num2);//2
        //demo2:
        int i = 5;
        i++;
        System.out.println("i = " + i);//6
        ++i;
        System.out.println("i = " + i);//7
        int a = ++i;
        System.out.println("a=" + a);//8
        System.out.println("i=" + i);//8
        int b = i++;
        System.out.println("a=" + b);//8
        System.out.println("i=" + i);//9
    }
}

　　4.2)赋值运算符

　　　　= 　　-=　　+=　　*=　　/=　　%=　　

　　　　注意:byte a ; a += 1 相当于 a = a + 1,但是为什么没报错,java内部进行了转换a = (byte)(a+1);

　　4.3)比较运算符

　　　　== 　　!= 　　<　　<=　　>　　>=　　instanceof

　　4.4)三元运算符

　　　　boolean类型表达式 ? 值1 : 值2; 　　//表达式为true时,结果为值1,否则,为值2.

　　4.5)逻辑运算符

　　　　& 　　| 　　!　　&& 　　|| 

　　　　& 与,值都为true,才是true

　　　　| 或,有一个值为true,就为true

　　　　&和&& 区别:当第一个表达式为false,&&双与不进行第二个表达式运算;而&单与进行运算

　　　　|和|| 区别:当第一个表达式为ture,||双或不进行第二个表达式运算;

　　　　　　

public class LuojiDemo{
    public static void main(String[] args) {
        //证明双&&,短路作用:
        boolean b = (false && (1/0 == 1));//没有报错
        System.out.println(b);
    }
}

　　4.6)位运算符

　　　　& 　　| 　　~　　^　　>> 　　<< 　　>>>

　　　　^异或:相同为假,不同为真

　　　　>> 右移

　　　　>>>无符号右移

　　　　>>和>>>的区别:变量为负数,则左侧一直用1补充,为正数一直用0补充;而>>>全部用0补充.

　　　4.7)运算符优先级

　　　　　　算数运算符>比较运算符>逻辑运算符>三元运算符>赋值运算符