您的位置：首页 > 编程语言 > Java开发

Java基础概念

2016-06-27 10:15 309 查看

标识符

package com.cloud.day1;

/*

标识符: 在Java程序中有些名字是可以自定义的，那么这些自定义的名字我们就

称作为自定义的标识符。

标识符要注意的细节：

      1. 标识符的组成元素是由字母（a-zA-Z）、数字(0-9) 、下划线(_)、美元符号($).

      2. 标识符不能以数字开头。

      3. 标识符是严格区分大小写的。

      4. 标识符的长度是没有长度限制的。

      5. 标识符的命名一般要有意义（要做到让人见名知意）

      6. 关键字、保留字不能用于自定义的标识符。

自定义标识符的规范：

   1. 类名和接口名单词的首字母大写，其他单词小写。比如： RunTime.

   2. 变量名与方法名首单词全部小写，其他单词首字母大写，其他小写。  比如： doCook()；

   3. 包名全部单词小写。

   4. 常量全部单词大写，单词与单词之间使用下划线分隔。  比如： UP_DIRECTION



判断一下那些是符合的标识符:

   12abc_   不合法  数字不能开头

   _12abc    合法

   $ab12#    不合法 #号不属于标识符组成元素。

   abc@123   不合法 @号不属于标识符组成元素。

关键字：关键字就是在java程序中具备特殊含义的标识符。关键字一般用于描述一个程序的

结构或者表示数据类型。

*/

public class Demo1 {

   public static void main(String[] args) {

      System.out.println("Hello,world");

   }

}

注释

package com.cloud.day1;

/*

需求：编写一个java程序模拟QQ登陆.

注释：注释就是使用文字对程序的说明，注释是写给程序员看的，编译器会忽略注释的内容的。

注释的类别：

   第一种：单行注释。   // 注释的内容

   第二种：多行注释。   /* 注释的内容
*/

/*

   第三种：文档注释.    /** 注释的内容
*/

/*

   文档注释也是一个多行注释。

注释要注意的细节：

   1. 单行注释可以嵌套使用，多行注意是不能嵌套使用的。

注释的作用：

   1. 使用文字对程序说明。

   2. 调试程序。

*/

public class Demo2 {

   public static void main(String[] args) {

      System.out.println("请输入用户名与密码");

      System.out.println("校验用户名与密码");

      System.out.println("aaa");

      System.out.println("展示好友列表");

   }

}

进制

package com.cloud.day1;

/*

软件 = 数据+ 指令+ 文档

常量: 常量就是程序在运行过程中其值不能发生改变的量。

常量的类别：

      整数常量   10 12

      小数常量 3.14

      布尔常量   布尔常量只有两个值： true(正确).
false(错误)

      字符常量   字符常量就是单个字符使用单引号引起来的内容我们称作为字符常量。

      字符串常量  字符串常量就是使用双引号引起来的内容称作为字字符串常量。

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

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

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

计算机的出现是为了服务于人类的，那么人类在现实生活中使用的数据基本上都是

十进制的数据，那么计算机是否有可以存储现实生活中的数据呢？如果可以存储

又以哪种形式存储呢？

二进制由来。

电脑记录我们现实生活中的数据都是使用二进制进行记录的，那么我们

就要懂得如何把十进制数据转换成二进制。

      十进制与二进制之间的转换：

      十进制转二进制的方法：使用十进制的数据不断除以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(八进制)------>    (十进制)



   八进制数据的特点：只有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（十进制）

*/

class Demo4{

   public static void main(String[] args){

      /*

      System.out.println(12); //整数常量

      System.out.println(3.14); //小数常量

      System.out.println(false); //布尔常量

      System.out.println('1'); //字符常量

      System.out.println("hello world"); //字符串常量

      如果一个数据没有加上任何的标识之前，默认就是十进制的数据。

      */

      System.out.println(10);// 十进制

      System.out.println(0b10); //二进制 , 如果一个数据要表示二进制，那么要在该数据的前面加上0b开头。

      System.out.println(010); //八进制数据，八进制的数据需要以0开头

      System.out.println(0x10); //十六进制数据，十六进制的数据需要以0x开头

   }

}

Java数据类型

数据类型

package com.cloud.day1;

/*

在现实生活中有很多数据是经常会发生变化的。

比如：天气、心情、  时间、股市...

变量：变量就是在程序运行过程中其值可以发生变化的量.

变量就是一个存储数据的容器。

容器具备什么特点：

   1. 容量(大小)。

   2. 存储一定格式的数据。

   3. 名字.

声明（定义）一个变量的格式：

   容量  变量名字 = 数据。

变量名的命名规范：首单词小写，其他单词首字母大写，其他小写。

java表示一个变量的容量多大是使用了数据类型描述的。

在java中的数据类型主要有两种数据类型

   基本数据类型

   引用数据类型

java中的八种基本数据类型：

   整数的数据类型：

      byte(字节)      8位（bit）
2^8 = 256    -128~127

      short(短整型)   16bit       2^16 = 65536

      int(整型)       32bit

      long(长整型)    64bit        2^64 =

   注意：如果一个整数没有加上任何的标识的时候，那么默认是int类型的数据。

   如果需要把该数据表示成一个long类型的数据，那么需要加数据后面加上L表示，L是不区分大小写的，但是建议使用大写。



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

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

   小数的数据类型：

      float(单精度浮点型)    32bit

      double(双精度浮点型)   64bit



   注意：如果一个小数没有加上任何标识的时候，那么该小数默认是double类型的数据，如果

   需要表示成float类型，那么需要在小数的后面加上f表示。f不区分大小写的。

   布尔类型：布尔类型只有两个值，true或者false。

      boolean    1字节或者4个字节

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

   如果使用boolean声明一个数组类型的时候，那么每个数组的元素占

   一个字节。

   字符类型：

      char 2字节（16bit）





八种基本数据类型：

   整数：byte short int long

   小数： float double

   布尔： boolean

   字符： char

字符串的数据类型是：String 引用数据类型,不属于基本数据类型。

*/

class Demo5

{

   public static void main(String[] args)

   {



      //需求1：定义一个变量存储一个正常人的年龄。

      byte age = 120;  //声明了一个byte类型的变量，该变量的名字叫age，把120存储到了age变量中。

      //改变变量的值

      age = 121;

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

      short money = 128;

      //需求3：定义一个变量存储老黎的钱。

      int bossMoney = 1000000000;

      //需求4: 定义一个变量存储周小川老板

      long  allMoney = 10000000000000000L;



      //存储小数

      float f = 3.14f;

      double d = 3.1415926537;

      boolean b = false;





      char c = 'a';

      String str = "hello world";

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

   }

}

变量

package com.cloud.day1;

/*

声明变量的方式：

   声明变量的方式一：

        数据类型变量名;

   声明变量的方式二：一次性声明了多个相同类型变量

        数据类型  变量名1 ，变量2....



注意：

   1. 变量是必须先声明再使用。

   2. 在一个作用域中不能声明同名的变量。

*/

class Demo6

{

   public static void main(String[] args)

   {

      //int age = 12; //声明一个变量



      int age ,height ;  //声明了变量

      //给变量赋值

      age = 10;

      height = 175;

      System.out.println(age);

      System.out.println(height);

   }

}

八大数据类型

package com.cloud.day1;

/*

java中的八种基本数据类型：

   整数：

      byte 、 short 、 int 、 long

   小数：

      float double

   字符：

      char

   布尔：

      boolean

字符串的类型： String(引用数据类型)

声明变量的方式：

   方式1：数据类型  变量名 = 数据;

   方式2：数据类型  变量名1 ，变量名2
......；

*/

class Demo1 {

   public static void main(String[] args) {

      String str = ""; //字符串还是字符呢？ ""字符串没有内容是属于一个空字符串。

      System.out.println(str);

   }

}

数据类型转换

package com.cloud.day1;

/*

数据类型转换：



   小数据类型-------->大数据类型     自动类型转换

   大数据类型--------->小数据类型    强制类型转换

   强制类型转换的格式：



        小数据类型  变量名 = (小数据类型)大数据类型



数据类型转换要注意的细节：

   1. 凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。

   2. 两个不同数据类型的数据在运算的时候，结果取决于大的数据类型。

*/

class Demo2

{

   public static void main(String[] args)

   {

      /*

      byte b= 11;   // 一个字节   一两碗

      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、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。



      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);

      */



      int i = 10;  //

      byte b = (byte) i;  // 一个整数没有加上任何标识的时候，默认是int类型的数据。

      //10 是一个常量，编译器在编译的时候就能够确认常量的值了，byte b = 10,在编译到的时候

      //java编译器就会检查到10并没有超出byte的表示范围，所以允许赋值。

      //java编译器在编译的时候并不能确认变量所存储的值，变量存储的值是在运行的时候才在内存中分配空间的。

      System.out.println(b);

   }

}

Java运算符

自增自减

package com.cloud.day1;

/*

++ （自增） :  自增就是相当于操作数+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 = temp;



   原理：

      1. int temp = i; // 声明了一个临时变量用于记录了i没有加1之前的值。

      2. 自增。 i = i+1;   i = 1;

      3. temp把用作了表达式的结果。



   i的值发生了几次变化：

        i = 0 -----> 1----> 0

   */

      int i = 0;

      i = i++; // 后自增...  后自增要使用到没有+1之前的值。

      System.out.println("i= "+i);

   }

}

赋值运算符

package com.cloud.day1;

/*

赋值运算符：

   = (赋值运算符)

   +=

   -=

   *=

   /=

   %=

*/

public class Demo4 {

   public static void main(String[] args) {

      int i = 10; // 把10赋予给i变量。

      i+=2;  // i = i+2;

      System.out.println("i = "+i);

      byte b1 = 1;

      byte b2 = 2;

      //b2 = (byte)(b2+b1); //报错。，需要强制类型转换

      b2+=b1;  //b2 = b2+ b1;   b2+=b1 在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换了。

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

   }

}

比较运算符

package com.cloud.day1;

/*

比较运算符：比较运算符的结果都是返回一个布尔值的。

   == (判断是否等于)

   ==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致.

   ==用于比较两个引用类型变量的数据时候，比较的是两个引用类型变量所记录的内存地址是否一致.

   != (不等于)

   > (大于)

   < (小于)

   >= (大于等于)

   <= (小于等于)

*/

public class Demo5 {

   public static void main(String[] args) {

      /*

      int a = 10;

      int b =10;

      System.out.println("10等于10吗？"+
(a==b));

      System.out.println("10不等于1吗？"+
(10!=1) ); //true

      */

      byte b = 10;

      long l = 30;

      System.out.println(l>b); //两个不同类型的数据是否可以比较呢.,可以的，但是两个不同类型的数据必须是兼用的数据。

      //这个比较的过程会先把b转换了long类型的数据，然后再进行比较。

      System.out.println('a'>50);

   }

}

逻辑运算符

package com.cloud.day1;

/*

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

   & （与,并且）

规律：只有左右变量同时为true，那么结果才是true，否则就为false。

   | (或,或者)

规律：只要两边的布尔表达式有一边为true，那么结果就为true，只有两边同时为false 的时候，结果才是false.

   ^ (异或)

规律：只要两边的布尔表达式结果不一致，那么结果就为true，如果左右两边的布尔表达式一致，那么就为false.

   ！ (非)

-------------------

   && (短路与\双与)

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

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

   不同点：使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了

   效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。

只有左边的布尔表达式为false时，双与的效率才要高于单与的.

   || (短路或\双或)

短路或与单或的相同点与不同点：

   相同点：运算的结果是一致的。

   不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。

   使用单或的时候发现左边的布尔表达式为true，还是会运算右边布尔表达式。

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

*/

public class Demo6 {

   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); //
true

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

      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:"+(!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); //
true

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

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

   }

}

位运算符

package com.cloud.day1;

/*

位运算符：位运算符就是直接操作二进制位的。

   & (与)

   | (或)

   ^ (异或)

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

应用：对数据加密.

   ~ (取反)

*/

public class Demo7 {

   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. 取出一个二进制数据的指定位数。要求读取该二进制数据的低4位

        00000000-00000000-00010100-01001101

      &   00000000-00000000-00000000-00001111

      ------------------------------------------

        00000000-00000000-00000000-00001101

*/

class Demo8{

   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;  // a = 3^5

      b = a^b;  // b = (3^5)^5 = 3

      a = a^b; // a = (5^3)^3 = 5

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

   }

}

移位运算

package com.cloud.day1;

/*

移位运算符：

   <<(左移)

规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数.

   3<<1 = 3 *2(1) = 6;

   3<<2 = 3*2(2) = 12

   3<<3 = 3*2(3) = 24

   >>(右移)

规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。

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

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

   >>>(无符号右移) ：

无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，

如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都

统一使用0补。

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

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

*/

public class Demo9 {

   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); // 1

      System.out.println(3>>>2);  //0

   }

}

三元运算符

package com.cloud.day1;

/*

三元运算符(三目运算符)

格式;

   布尔表达式？值1:值2 ;

三元运算符要注意的细节：

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

*/

public class Demo10 {

   public static void main(String[] args) {

      /*

      int age = 26;

      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);

   }

}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航