Java基础--变量和关键字

 /*
标识符：在java程序中有些名字是可以自定义的，那么这些自定义的名字我们就叫称作为自定义的标识符。


标识符注意的细节：
1.标识符的组成元素是由字母（a-zA-Z）、数字（0-9）、下划线（—）,类元符号（$）
2.标识符不能以数字开头
3.标识符严格区分大小写的。
4.标识符的长度是没有长度限制的。
5.标识符的命名一半要有意义（要做到让人见名思意）。
6.关键字、保留字不能用于自定义的标志符。


自定义标识符的规范：
1.类名和接口名单词的首字母大写，其他单词小写，比如：RunTime。
2.变量名与方法名首字母全部小写，其他单词首字母大写，其他小写。比如，doCook
3.包名全部单词小写。
4.常量全部单词大写，单词与单词之间使用下划线分隔。比如，TRP_DIRCTION


判断以下哪些是符合的标识符：
12abc_      不合法  数字不能开头
_12abc      合法
$12ab#      不合法 #号不属于标识符组成元素
abc@123     不合法 @号不属于标识符组成元素


关键字：关键字就是在java程序中具备特殊含义的标识符。关键字一般用于描述一个程序的结构或者表示数据类型
*/
class Demo1


{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}
}

/*
需求：编写一个java程序模拟QQ登陆
注释：注释就是使用文字对程序的说明，注释是写给程序员看的，编译器会忽略注释的内容


注释的类别：


第一种：单行注释。//注释的内容
第二种：多行注释。/*注释的内容*/
/*
第三种：文档注释。/** 注释的内容*/
/*
文档注释也是一个多行注释


注释要注意的细节：
  1.单行注释可以嵌套使用，
  2.多行注释是不能嵌套使用的


 注释的作用：
 1.使用文字对程序的说明
 2.调试程序
*/


class Demo2
  
{
public static void main(String[] args) 
{
System.out.println("输入用户名与密码");
System.out.println("校验用户名与密码");
System.out.println("展示好友列表");
}
}

/*
软件=数据+指令+文档（使用者文档+开发者文档）
文档注释与多行注释的区别：
多行注释的内容不能用于生成一个开发者的文档。
而文档注释的内容可以生成一个开发者的文档。


使用javadoc开发工具即可生成开发者文档。


    javadoc工具的使用格式：


      javadoc -d 存放文档的路径 java的源文件
  使用Javadoc工具要注意的细节：


  1.如果一个类需要使用javaodoc工具生成一个软件的开发者文档，那么该类必须使用public修饰。
  2.文档注释的内容一般都是位于类或者方法的上面。


写注释的规范：单行注释一般位于代码的右侧，多行注释与文档注释一般位于类与方法的上面
*/
/**
该类是用于模拟QQ软件的
@author sophia 
@version 1.0
*/


public class Demo3 
{
/**
操作的流程如下：
1.首先先输入用户名密码
2.校验用户名与密码
3.展示好友列表
*/
public static void main(String[] args) 
{
System.out.println("请输入用户名和密码");
System.out.println("校验用户与密码");
System.out.println("展示好友列表");
}
}

/*
软件=数据+指令+文档


常量：常量就是程序在运行过程中其值不能发生改变的量。
常量的类别：
     整数常量  10 12
小数常量   3.14
布尔常量  布尔常量只有两个值：true（正确）。false（错误）
字符常量   字符常量就是单个字符使用单引号引起来的内容我们称之为字符常量
字符串常量 字符串常量就是使用双引号引起来的内容称作为字符串常量


整数常量的表现形式：整数的表现形式主要以不同的进制表现出来（二进制、八进制、十进制、十六进制）


进制：十进制（0~9）、星期（七进制 0~6）、小时（12进制 0~11、24进制 0~23）


进制：用有限的数字符号代表所有的数值


计算机的出现是为了服务于人类的，那么人类在现实生活中使用的数据基本上都是十进制的数据，那么计算机是否可以存储现实生活中的数据呢？如果可以存储又以哪种形式存储呢？






二进制由来：
在早期的计算机电脑是由开关组成的。
开关只有两种状态：开或者关
使用开关的状态用于描述现实生活中的数据。
一个开关只有两种状态（0,1），那么就只能记录两个数据而已，但是现实生活中是有很多数据的，那么电脑如何记录这些数据呢？


用多个开关组合起来产生多种状态，每种状态就可以代表一个数据了。
3个开关   2^3=8
关关关 000
关关开001


电脑记录我们现实生活中的数据都是使用二进制进行记录的，那么我们就要懂得和把十进制转换成二进制。


十进制与二进制之间的转换：
  十进制转二进制的方法：使用十进制的数据不断除以2，直到商为0为止，从下往上取余数就是对应的二进制
10（十进制）------->1010（二进制）
二进制转十进制：使用二进制的每一位乘以2的n次方，n从0开始，每次递增1，然后把各部分的数据相加即可
1110（二进制）------->14(十进制)


二进制的弊端：二进制的书写太长额，不方便人类记忆
二进制的数据的特点：由0~1组成
解决方案：每三个二进制位就记录一个数字
1000（十进制）------->001,111,101,000(二进制)=1，7，5，0


一个八进制的数据就是相当于三个二进制位
十进制与八进制之间的转换：
      十进制转八进制：使用十进制的数据不断除以8，直到商为0，从下往上取余数就是对应的八进制。
     45（十进制）------>55(八进制)
  八进制转十进制：使用八进制的每一位乘以8的n次方。n从0开始，每次递增1，然后把各部分的数据相加即可
  23（八进制）--------->  19(十进制)
  八进制数据的特点：只有0~7这八个字符组成。
  十六进制的数据：0~9，a(10),b(11),c(12),d(13),e(14),f(15)
  十六进制的数据是有0~9，a~f这几个字符组成的。


  十进制转换成十六进制：使用十进制的数据不断除以16，直到商为0为止。从下往上取余数就是对应的十六进制。
  38（十进制）----->26（十六进制）


  十六进制转换成十进制：使用十六进制的每一位乘以16的n次方，n从0开始，每次递增1，然后把各部分的数据相加起来


  34（十六进制）------->52（十进制）


  四个二进制位是一个十六进制的数据


  1010101010111（二进制）------>1557(16进制)
  00001,0101,0101,0111-------->1,5,5,7


  1a(十六进制)----->1，1010(二进制)
*/






class Demo4 
{
public static void main(String[] args) 
{
/*
System.out.println(12);//整数常量
System.out.println(3.14);//小数常量
System.out.println(true);//布尔常量
System.out.println("hello world");//字符串常量
System.out.println('1');//字符常量
如果一个数据没有加上任何标识之前，默认就是十进制数据。*/
System.out.println(10);//十进制
System.out.println(0b10);//二进制，如果一个数据要表示二进制，那么就要在该数据的前面加上0b开头
System.out.println(010);//八进制数据，八进制数据需要0开头
System.out.println(0x10);//十六进制数据，八进制数据需要0x开头





}
}

在现实生活中有很多数据是经常会发生变化的。
比如：天气、心情、时间、股市。。。。


变量：变量就是在程序运行过程中其值可以发生变化的量
变量就是一个存储数据的容器
容器具备什么特点：
    1.容量（大小）
2.存储一定格式的数据。
3.名字
声明（定义）一个变量的格式：


     容量  变量名字=数据，


变量名的命名规范：首单词小写，其他单词首字母大写，其他小写。
 java表示一个变量的容量多大是使用了数据类型描述的。
 在java中的数据类型主要有两种数据类型：
     基本数据类型


引用数据类型
java中的八种基本数据类型：
     整数的数据类型：
byte(字节)  8位（bit） 2^8=256  -128~127
short（短整型） 16bit  2^16=65536 
int（整型） 32bit（位）
long（长整型）64bit（位）
注意：如果一个整数没有加上任何标识的时候，那么默认是int类型的数据。
如果需要把该数据表示成一个long类型的数据，那么需要加数据后面加上L表示，L是不区分大小写的但是建议使用大写。




疑惑：存储整数可以使用四种数据类型，那么具体怎么选择使用？


选用数据类型的原则：在能满足需求的情况下，能小则小。节省内存空间。


小数的数据类型：
float（单精度浮点型）32bit
double（双精度浮点型）64bit
注意：如果一个小数没有加上任何标识的时候，那么默认是int类型的数据，
如果需要把该数据表示成float型，那么需要在小数后面加上f表示。f不区分大小写


布尔类型：布尔类型只有两个值 true和false
     boolean 1字节或者4个字节
java规范2.0（java白皮书）


如果使用boolean声明一个基本类型的变量时，那么该变量占4个字节
如果使用boolean声明一个数组类型的时候，那么每个数组占用1个字节




字符类型：
   char  2个字节（16bit）


字符的存储原理：程序------->码表--------->硬盘


八种基本的数据类型：
整数：byte short int long
小数：float double
布尔：boolean
字符： char


字符串数据类型：string 属于引用数据类型不属于基本数据类型
*/


class Demo5 
{
public static void main(String[] args) 
{
//需求：定义一个变量存储一个正常人的年龄。
byte age=120;//声明了一个byte类型的变量，该变量的名字叫age,把120存储到了age变量中。
//改变变量的值
age=121;


//需求2：定义一个变量存储老师口袋钱。

short money=128;
//需求3：定义一个变量存储老李的钱
int bossMoney=10000000;
//需求4：定义一个变量存储周小川老板的钱
long allMoney=1000000000000L;


//存储小数
float f=3.14f;
double d=3.141592637;
boolean b=false;


char c='a';
String str="hello world";


System.out.println(str);//需要获取一个变量存储的数据，只需要使用变量名即可。
}
}

/*
声明变量的方式：
   声明的变量方式一：
      数据类型 变量名；
 声明的变量方式二：一次性声明了多个类型相同的变量
 数据类型 变量名1，变量名2....
  
 注意：
 1.变量必须先声明再。
 2.在一个作用域中不能声明同名的变量
*/
class Demo6 
{
public static void main(String[] args) 
{
int age1=12;//声明一个变量
int age,height;
age=10;
height=175;
System.out.println(age);
System.out.println(height);

}
}

/*
java中的八种基本数据类型：
整数：byte,short,int,long
小数：float,double
布尔：boolean
字符：char
字符串类型：String(引用数据类型)


声明变量的方式：
方式1：数据类型 变量名=数据；
方式2：数据类型 变量名1，变量名2.....


*/
class Demo1 {


public static void main(String[] args) {
String str="a";//字符串还是字符呢？(字符串)
String str1="";//""字符串没有内容是属于一个空字符串。
System.out.println(str);
System.out.println(str1);
}
}

/*
数据类型转换：
    
小数据类型------->大数据类型   自动类型转换
    大数据类型------->小数据类型   强制类型转换


强制类型转换的格式：


小数据类型  变量名=（小数据类型）大数据类型


数据类型转换要注意的细节：
   1.凡是byte、short、char数据类型数据在运算的时候都会自动转换成int类型的数据再运算
   2.两个不同数据类型的数据在运算的时候，结果取决于大的数据类型。




在计算机中如果一个二进制数据的最高位是1，那么该数据肯定是一个负数
如果一个二进制数据的最高位是0，那么该数据肯定是一个正数
在计算机中存储的是补码


负数的存储过程：-7-------------->11111001
1.先取负数的绝对值求出该绝对值得二进制（原码）
2.原码取反得到反码
3.反码+1得到了补码。
00000111（原码）
取反
11111000（反码）
+   00000001
---------------------
    11111001（补码）






如何通过补码求出真实的数据
步骤：1.补码先-1
     2.取反
 3.在数据前面加上负号即可


 11111001（补码）
- 00000001
-------------------
 11111000
取反
------------------------------
          00000111------  -7


*/


class Demo2 
{
public static void main(String[] args) 
{
/*
byte b=11;//8bit
short s=b;//把b变量存储的值赋给s变量 .2字节
int i=s;//i是4个字节
long l=i;//l是8个字节
System.out.println(l);



int i=128;//4个字节
byte b=(byte)i;//1个字节
System.out.println(b);//-128


//如果是负数，那么最高位肯定是1，正数的二进制位的最高位是0
         System.out.println(Integer.toBinaryString(-7));//sun给我们提供一个功能Integer.tobinaryString查看一个数据的二进制数据
   // 11111001(补码)

byte b1=1;
byte b2=2;
byte b3=(byte)(b1+b2);
System.out.println(b3);//3



System.out.println('a'+1);//98



int i=10;
long l=20;
i=(int)(i+l);
System.out.println(i);



byte b=10;//一个整数没有加上任何标识的时候，默认是int类型的数据。
//10是一个常量，编译器在编译的时候就能够确认常量的值了，byte b=10在编译的时候。
//java编译器就会检查到10并没有超出byte的表示范围，所以允许赋值。

System.out.println(b);
*/


int i=10;//会报错
byte b=i;//java编译器在编译的时候并不能确认变量所存储的值，变量存储的值是在运行的时候才在内存中分配空间
System.out.println(b);
}
}

/*
算数运算符：
+（正数，加法，连接符）


连接符的作用：让任何的数据都可以与字符串进行拼接。
如果加号用于字符串的时候，那么+号就是一个连接符，并不是做加法功能了。
连接符要注意：任何类型的数据与字符串使用连接符，那么结果都是字符串类型的数据
-
*
/(除法)
%(取模，取余数)
++（自增）
--（自减）




*/


class Demo3 
{
public static void main(String[] args) {
/*int i1=+1;//
        int i2=2;




System.out.println(i1+" world");//"hello world",1 world
   //计算机每次运算的时候只能取两个数据运算。
System.out.println(1+2+3+" world"+1+2+3);//6 world123
/*
1+2+3+"world"+1+2+3
3+3+"world"+1+2+3
6+"world"+1+2+3
"6world"+1+2+3



int a=10;
int b=3;
System.out.println(a/b);//3

double a=12.0;
int b=3;
System.out.println(a/b);//4.0
*/
//在java中做取模运算时，结果的正负号是取决去被除数。
System.out.println("结果是:"+(10%3));//1
System.out.println("结果是:"+(10%-3));//1
System.out.println("结果是:"+(-10%3));//-1
System.out.println("结果是:"+(-10%-3));//-1


}
}

/*
++(自增)：自增就是相当于操作数+1
前自增：++位于操作数的前面。比如： ++a


前自增：先自增，后使用




后自增：先使用，后自增
*/




class Demo4 
{
public static void main(String[] args) 
{
/*
int a=0;
//int sum=++a;//前自增  a=a+1,sum=a
int sum=a++;//后自增 sum=0，a=a+1
System.out.println("sum= "+sum +" a= " + a);//1


后自增在jvm的运行原理：
因为后自增要使用没有+1之前的值，那么jvm会先声明一个变量用于保存没有+1之前的值。


int i=0;
i++;


原理：
   1.int temp=i;//temp=0;  声明了临时变量用于记录了i没有加1之前的值。
2.自增。i=i+1; i=1;
3.return temp(把temp用作了表达式的结果);
i的值发生了几次变化：
i=0----->1------>0(三次变化)


*/


int i=0;
//i++;
//System.out.println("i= "+i);//1
i=i++;//后自增。。。后自增要使用到没有+1之前的值。
System.out.println("i= "+i);//0
}
}

/*
自减：操作数-1.


前自减：位于操作数的前面。--操作数
前自减：先自减后使用。


后自减：位于操作数的后面。操作数--
后自减: z先使用后自减


*/
class Demo5 
{
public static void main(String[] args) 
{
/*
int i=1;
//int sum=--i;//前自减 i=i-1,sum=i
int sum1=i--;//后自减 sum=i;i=i--
//System.out.println("sum= "+sum);//0
System.out.println("sum1= "+sum1);//1
*/


int num=10;
int sum=10*num++;//后自增 100
int sum=10* ++num;//前自增 110
System.out.println("sum="+sum);
}
}

/*
赋值运算符：
=（赋值运算符）
+=
-=
*=
/=
%=
*/


class Demo6 
{
public static void main(String[] args) 
{
int i=10;//把10赋予给变量。
i+=2;//i=i+2;
System.out.println("i= "+i);


byte b1=1;
byte b2=2;
//b2=b2+b1;//报错。需要强制类型转换  ----->b2=(byte)(b2+b1)
b2+=b1;//b2=b2+b1;b2+=b1在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换


System.out.println("b2: "+b2);
}
}

/*
比较运算符：比较运算符的结果都是返回一个布尔值的。
   ==（判断是否等于）
   ==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一样。
   ==用于比较两个引用类型变量的数据时候，比较的是两个引用类型变量所记录的内存地址是否一致。
   ！=（不等于）
   >(大于)
   <（小于）
   >=（大于等于）
   <=（小于等于）
*/


class Demo7 
{
public static void main(String[] args) 
{
/*
int a=10;
int b=10;
System.out.println("10等于10吗？"+(a==b));//true
System.out.println("10不等于1吗？"+(10!=1));//true
*/


byte b=10;
long l=30;//（兼容）
//boolean b1=true;（不兼容）
System.out.println(l>b);//两个不同类型的数据是否可以比较呢  可以比较的，但是两个不同数据类型必须是兼容的
//这个比较的过程会先把b转换成long类型，然后再进行比较。
System.out.println('a'>50);


}
}

/*
逻辑运算符


逻辑运算符的作用是用于连接布尔表达式的。


&(与，并且)
规律：只有左右变量同时为true,那么结果才是true,否则就为false.


|（或,或者）
规律： 只要两边的布尔表达式有一边为true，那么结果为true,只有两边同时为false的时候，结果才是false


^（异或）
规律：只要两边的布尔表达式结果不一致，那么结果为true，如果左右两边的布尔表达式一致，那么就为false.
!（非）
---------------------------------
&&（短路与\双与）


短路与和单与符号的相同与不同点：


相同点：短路与和单与的运算结果是一样的。


不同点：使用短路与的时候，如果左边的布尔表达式为false，则不会再运算右边的布尔表达式，从而提高了效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式。
 只有左边的表达试是false,双与的效率要高于单与的效率。


 ||（短路或\双或）：
 短路或与单或的相同点与不同点：


 相同点：运算的结果是一致的。
 不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。
         使用单或的时候发现左边的布尔表达式为true，还是会运算右边的布尔表达式


需求： 要求两年或两年以上的工作经验，年龄大于18岁。


*/
class Demo8 
{
public static void main(String[] args) 
{

int workAge=2;
int age=24;
System.out.println(workAge>=2||age++>18);
System.out.println("age:"+age);


/*
System.out.println(true&true);//true
System.out.println(true&false);//false
System.out.println(false&true);//false
System.out.println(false&false);//false



System.out.println(true|true);//true
System.out.println(true|false);//ture
System.out.println(false|true);//ture
System.out.println(false|false);//false



System.out.println(true^true);//false
System.out.println(true^false);//true
System.out.println(false^true);//true
System.out.println(false^false);//false



System.out.println(!!!true);//false

System.out.println(true&&true);//true
System.out.println(true&&false);//false
System.out.println(false&&true);//false
System.out.println(false&&false);//false


*/


System.out.println(true||true);//true
System.out.println(true||false);//ture
System.out.println(false||true);//ture
System.out.println(false||false);//false








}
}

/*
位运算符：位运算符就是直接操作二进制位的。
&（与）
6&3=2
   00000110      可以把1看成true
&  00000011       把0看成false
--------------    
   00000010    2




 
|（或）


  00000110      可以把1看成true
|  00000011       把0看成false
--------------    
   00000111    7


^（异或）


   00000110    6  可以把1看成true
^  00000011    3   把0看成false
--------------    
   00000101    5
^  00000011    3
------------------
   00000110    6


   规律：如果操作数A连续异或同一个操作数两次，那么结果还是操作数A


   应用：对数据进行加密


~（取反）
   00000111                  11111000        00001000   -8
~                         -  00000001
-------------            ---------------
   11111000                  11110111
*/




class Demo9 
{
public static void main(String[] args) 
{
System.out.println(6&3);//2
System.out.println(6|3);//7
System.out.println(6^3);//5
System.out.println(~7);//-8


}
}

/*
位运算符可能出现的笔试题目：
   1.交换两个变量的值。
   2.取出一个二进制数据的指定的位数


*/




class Demo10 
{
public static void main(String[] args) 
{
int a = 3;
int b = 5;
        
/*
第一种方式： 定义第三方变量。
int temp = a;//3
a = b;//a=5 
b = temp;


方式2：相加法.缺点：两个int类型的数据相加，有可能会超出int的表示范围。





a=a+b;//a=8
b=a-b;//b=8-5=3
a=a-b;//a=8-3=5



方式3： 可以使用异或。


        */


a = a^b;
b = a^b;
a = a^b;
System.out.println("a = " + a+" b = " + b);


}
}

/*
移位运算符：
    <<(左移)(一个操作数进行左移运算的时候，右边空缺位用0补)
规律：一个操作数进项左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数


   00000011
3<<1 00000110
3<<2    00001100
3<<3    00011000

>>（右移）（一个操作数在进行右移运算的时候，如果该操作数是一个正数，那么左边空缺位使用0补，如果该操作数是一个负数，那么左边的空缺位用1补）
规律：>>(右移)一个操作数在做右移运算的时候，实际上就是等于该操作除以2的n次方，n就是右移的位数。
        00000011
3>>1    00000001
3>>2    00000000


3>>1=3/2(1)=1
3>>2=3/2(2)=0




>>>（无符号右移）
无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，如果操作数是一个负数，那么左边的空缺位使用1补。
而使用无符号右移的时候，不管是正数还是负数都统一使用0补




笔试题目：使用最高效率算出2乘以8的结果


2<<3 = 2*2(3)=16;




*/


class Demo11 
{
public static void main(String[] args) 
{
/*
左移
System.out.println(3<<1);//6
System.out.println(3<<2);//12
System.out.println(3<<3);//24


右移
*/
System.out.println(3>>1);//6
System.out.println(3>>2);//12
System.out.println(3>>3);//24




}
}

/*
三元运算符（三目运算符）


格式：
    布尔表达式？值1：值2 ；


三元运算符要注意的细节：
   使用三元运算符的时候：一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果




*/






class Demo12 
{
public static void main(String[] args) 
{
/*
int age = 26;


//System.out.println(age>=18?"成年人":"未成年人");
String result=age>=18?"成年人":"未成年人";


System.out.println(result);
*/


int a=1;
int b=2;
int c=3;


int result = a*b+c/2+2*(a+b)/c;
System.out.println("result"+result);
}
}