标签：java int day01 数据类型笔记运算符 ++ 类型表达式

笔记

基础语法

一、注释

单行注释：

//123123

多行注释：

/*
多行注释
*/

文档注释：

/**
*@Description 111
*@Author 111
*/

二、基本数据类型

1、数据存储的单位

位、字节、字是计算机数据存储的单位。位是最小的存储单位，每一个位存储一个1位的二进制码，一个字节由8位组成。而字通常为16、32或64个位组成。

位（bit）:是计算机中最基本的单位，位是最基本的概念，在计算机中，由于只有逻辑0和逻辑1的存在，即每一个逻辑0或者1便是一个位
字节（byte）:计算机中处理数据的基本单位，是由八个位组成的一个单元，8个bit组成1个Byte
字（word）：代表计算机处理指令或数据的二进制数位数，是计算机进行数据存储和数据处理的运算的单位，在常见的计算机编码格式下，一个字等于两个字节（十六位）（1word = 2Byte = 16bit）

2、基本数据类型

Java基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

基本数据类型的字节数及表示范围

整型（4个）： byte（字节型）、short（短整型）、int（整型）、long（长整型）

byte a = 100; 
short s = 1000; 
int a = 100000; 
long a = 100000L;

注. 声明long类型数据的时候，后面需要加L或者l （一般加大写L）；

浮点型（2个）：float（单精度型/浮点型）、double（双精度型）

float f1 = 1.1f;
double d1 = 1.2;

注.

声明float类型的数据的时候加f或者F;
double类型的数据的有效位数 15~16；
float类型的数据有效位数是 6~7；

字符（1个）： char（字符型）

注.声明char类型的数据的时候，使用单引号声明。并且单引号里面只能放一个元素；

char name = 'a'

布尔类型:（1个）： boolean(布尔类型）

一般用来做逻辑判断，一般用于流程控制，数据值只有true或false，适用于逻辑计算。

包装类型
Java 是面向对象的语言，但是为了便于开发者的使用，Java 中却沿用了 C 语言的基本数据类型，在进行基本的数据计算时，开发者可以直接使用基础类。但是基本数据类型是不具备对象的特征的，不能调用方法，而且基本数据类型不能存入集合中，所以就需要将基础数据类型实例封装为 Java 对象，使其具有了对象的属性和方法。

基本类型与包装类的区别

存储位置不同：基本数据类型直接将值放在栈中；包装类型是把对象放在堆中，然后通过对象的引用来调用他们；
初始值不同：int的初始值为 0 、 boolean的初始值为false ；包装类型的初始值为null ；
使用方式不同：基本数据类型直接赋值使用就好；在集合如 coolectionMap 中只能使用包装类型；

基本类型与包装类的相互转换

手动转换
基本数据类型 → 包装类：通过对应包装类的构造方法实现，除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象。
包装类 → 基本数据类型：通过包装类的实例方法 xxxValue() 实现; // xxx表示包装类对应的基本数据类型
自动装箱&自动拆箱（jdk1.5以后）
基本类型添加到集合中时，进行自动装箱包装类型在涉及到运算的时候，“加，减，乘，除” 以及 “比较 equals,compareTo”，进行自动拆箱

三、简单数据类型转换

容量类型排序：

简单类型数据间的转换,有两种方式:自动转换和强制转换

1、自动类型转换

public static void main(String[] args) {
    //1.多个类型数据混合运数时，系统会按最大的类型进行转换
    int a = 10;
    //float a1 = a + 1.1; //错误  结果类型一个是double
    float a2 = a + 1.1F;  //结果类型一个是float
    double a3 = a + 1.1;  //结果类型一个是double
    //2.容量大的赋值给容量小的肯定会报错
    //int b = 1.1; //错误 原因：double -> int
    //3.(byte，short) 和 char之间不会相互自动转换
    byte b1 = 10; //正确
    int b2 = 1;
    //byte b3 = b2; //错误 原因：变量赋值，判断该类型
    //char c1 = b1; //错误 原因：byte不能自动转换为char
    //4.byte，short，char该三个数据类型计算，计算时首先转换为int类型
    byte c1 = 1;
    short c2 = 2;
    //short c3 = c1 + c2; //错误 原因：计算时首先转换为int类型
    int c3 = c1 + c2; //正确

}

强制类型转换

强制类型转换：将容量大的数据类型转换为容量小的数据类型 --> 总结：大容量转小容量

	public static void main(String[] args) {
        //1.精度降低或溢出
        int i = (int) 1.9; //结果 1
        //2.强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
        //int x = (int) 10 * 3.5 + 6 * 1.5;//编译错误
        int x = (int) (10 * 3.5 + 6 * 1.5);//正确 (int)44.0 -> 44
        //3.char类型可以保留int的常量值，不能保存int的变量值需要强转
        char c = 100; //保留int的常量值
        int i = 100;
        //char m = i; //错误
        char m = (char) i; //正确
 }

隐含强制类型转换（初始化）

在变量的初始化时，整数的默认类型是 int。byte b = 123; 123 默认是 int 类型，他会隐含强制转换为低级别的 byte 和 short 类型，所以不用显示强制转换；但是 int 类型只能显式强制转换为 long 型，所以 long a = 123L;
浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

其他类型转换

包装类型向字符串转换

 String str = "11.1";
 Double d = new Float("11.1");     
 String str1 = d.toString();

字符串向包装类型转换

String str = "11.1";
 Double d = new Float("11.1");
 Double d = Double.parseDouble("11.1");  
 Double d = Double.valueOf("11.1");

基本类型向字符串的转换

Integer a = 1;
a.toString();//调用转字符串的方法
String s =a +  "";//加上""自动转换String类型
String.valueOf(a);//使用String的方法

引用数据类型
6.1 类Class引用
Object ：Object是一个很重要的类，Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数组）都实现这个类的方法，用Object可以定义所有的类。

Object object = new Object();
Integer Integer=(Integer)object;//

String ：String类代表字符串，Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例来实现。检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本、在该副本中、所有的字符都被转换为大写或小写形式。
Date ：Date表示特定的瞬间，精确到毫秒。Date的类一般现在都被Calendar 和GregorianCalendar所有代替
Void ：Void 类是一个不可实例化的占位符类，它保持一个对代表 Java 关键字 void 的 Class 对象的引用。

6.2 接口interface引用
List：列表，此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。List 接口提供了两种搜索指定对象的方法。从性能的观点来看，应该小心使用这些方法。在很多实现中，它们将执行高开销的线性搜索。 List 接口提供了两种在列表的任意位置高效插入和移除多个元素的方法。
add() : 在列表的插入指定元素。
remove()：移除列表中指定位置的元素。
get(int index)：返回列表中指定位置的元素。

6.3 数组引用
数组：存储在一个连续的内存块中的相同数据类型（引用数据类型）的元素集合。
数组中的每一个数据称之为数组元素，数组中的元素以索引来表示其存放的位置，索引（下标）从0开始。

四、变量与常量

变量

变量就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

type varName [=value]
//数据类型 变量名 = 值；

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束

public class Demo08 {
    //类变量 static
    static double salary = 2500;
    //属性: 变量
    //实例变量:从属于对象; 如果不自行初始化，这个类型的默认值 0 0.0
    //布尔值: 默认是false
    //除了基本类型，其余都是null;
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量:必须声明和初始化值
        int i = 10;
        System.out.println(i);
    //new Demo08;写完之后，选定Alt+Enter点击第一个选项即可形成下方一代码
        //变量类型  变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        //类变量 static
        System.out.println(salary);
    }
    //其他方法
    public void add(){
    }
}

常量

常量：初始化后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在运行过程中不允许被改变。

public class Demo09 {
    //修饰符，不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则例：lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX _VALUE
类名：首字母大写和驼峰原则：Man GoodMan
方法名：首字母小写和驼峰原则：run() runRun()

五、运算符

自增和自减

a++和++a 都是自增运算符，俩者的区别在于对变量a的值进行自增的时机不同

==> a++是先取值后自增； ++a是先自增后取值。

例如 x = 3；

（x++）+（++x） = 8;

解=> x++此时取值为3，而后自增令x=4，那么参与++x的初始值x为4，则在自增后取值为5

所以，3+5=8

面试题1：

var a=10 ; b=20; c=4; 求++b+c+a++的值

++b=21；a++=10；c=4； => ++b+c+a++=21+4+10=35;

1.算数运算符

基本四则运算符：加减乘除模（+ - * / %）

都是二元运算符，使用时必须要有左右两个操作数
int/int结果还是int类型，而且会向下取整，如果想要的到小数点后的结果，可用double类型来接收
做除法和取模时，左右操作数不能为0
%不仅可以对整数取模，也可以对double类型取模，但是没有意义两侧操作数类型不一致时，向类型大的提升

增量运算符+= -= *= %=

该种操作符将结果赋值给左操作数
只有变量才能使用该运算符，常量不能使用

自增/自减运算符++ --

如果单独使用，【前置++】和【后置++】没有任何区别
如果混合使用，【前置++】先+1，然后使用变量+1后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1

关系运算符

关系运算符主要有六个：== != < > <= >=，其计算结果时true或者false
当需要多次判断时，不能连着写，比如：3 < a <5，这样写，3 < a的结果会是true或者false，再和后面的5比较无意义

逻辑运算符

逻辑运算符主要有三个：&& || !，运算结果都是boolean类型

1.逻辑与&&

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。

两个表达式都为真，结果才是真，只要有一个是假，结果就是假。

2.逻辑或||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。

左右表达式至少有一个为真，则结果为真。

3.逻辑非！

语法规则：! 表达式
真变假，假变真。

4.短路求值

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

注意：

对于&&，如果左侧表达式值为false，则表达式结果一定是false，无需计算右侧表达式
对于||，如果左侧表达式为true，则表达式结果一定是true，无需计算右侧表达式
&和|如果表达式结果为booleam时，也表示逻辑运算，但与&& ||相比，他们不支持短路求值

位运算符

位运算符主要有四个：& | ~ ^，除~是一元运算符外，其余都是二元运算符。
位操作符表示按二进制位运算。

1、按位与&：如果两个二进制位都是1，则结果为1，否则结果为0.
2、按位或|：如果两个二进制位都是0，则结果为0，否则结果为1.
注意：当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.
3、按位取反~：如果该位为0则转为1，如果该位为1则转为0.
4、按位异或^：如果两个数字的二进制位相同，则结果为0，相异则结果为1，如果两个数相同，则异或结果为0.

1.移位运算符

移位运算符有三个：<< >> >>>，都是二元运算符，且都是按照二进制比特位来运算的。

1、左移<<：最左侧位不要了，最右侧补0.
注意：向左移位时，丢弃的是符号位，因此正数左移可能会变成负数。
2、右移>>：最右侧位不要了，最左侧补符号位（正数补0，负数补1）
3、无符号右移>>>：最右侧位不要了，最左侧补0.

注意：

左移1位，相当于原数字2，左移N位，相当于原数字2的N次方
右移1位，相当于原数字/2，左移N位，相当于原数字/2的N次方
由于计算机计算移位效率高于计算乘除，当某个代码正好乘除2的N次方时可以用移位运算代替
移动负数位或者移位位数过大都没有意义

条件运算符

条件运算符只有一个: 表达式1 ? 表达式2 : 表达式3
当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;
当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.
也是 Java 中唯一的一个三目运算符, 是条件判断语句的简化写法.
注意：

表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换。
表达式不能单独存在，其产生的结果必须要被使用。

连接符

public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }
}

1020
30

""在左面后面为string类型，""在右面前面正常为int类型；

三元运算符

public class Demo02 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true，则结果为y，否则为z
        int score = 80;
        String type = score > 60 ? "及格":"不及格";
        System.out.println(type);
    }
}
及格

标签：java,int,day01,数据类型,笔记,运算符,++,类型,表达式
From： https://www.cnblogs.com/wjm0401/p/16714541.html

java学习笔记day01

笔记