编程基础（2）

Java语言基础的组成

关键字

用于定义数据类型的关键字：

class（类）  interface（接口）  byte（字节）   short（短整型）  int（整型）  long（长整型） float（浮点数）  double（双浮点数）   char（字符型）   boolean（布尔型）  void（无返回值）

用于定义数据类型的关键字：

true（成立）   false（不成立）   null（空）

用于定义流程控制的关键字：

if（如果）  else（或者）   switch（选择）  case（选项）  default（默认）  while（当..时） do（做）  for（为）   break（停止）   continue(继续)    return(返回)

用于定义访问权限修饰符的关键字：

private(私有的)   protected(受保护的)   public(公有的)

用于定义类，函数，变量，修饰符的关键字：

abstract(抽象的)   final(不变的)  static(静态的)  synchronized(线程同步)

定义类与类之间关系的关键字：

extends(继承)   implements(实现)
定义建立实例及引用实例，判断实例：

new(新建)  this(本类)     super(父类)   instanceof(实例运算)
异常处理：

try(尝试)   catch(处理)  finally(一定执行)   throw(方法体内抛出)   throws(方法体上抛出)

包关键字:

package(包)  import(导入)

其它：

native(本地方法)   strictfp(严格)   transient(短暂)  volatile(不稳定)  assert(断言)

标识符

1.标识符
  (1)在程序中自定义的一些名称。
  (2)由26个英文字母大小写，数字，0~9和符号_与$组成。
  (3)定义合法标识符规则：
  数字不可以开头。
  不可以使用关键字.
  (4)java中严格区分大小写。
  (5)为提高阅读性，起名字尽量有意义。
 2.java中的名称规范：
  (1)包名：多单词组成时所有字母都小写。如:xxxyyyzzz
  (2)类名，接口名：多单词组成时，所有单词的首字母大写。如：XxxYyyZzz
  (3)变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。如：xxxYyyZzz
  (4)常量名：所有字母都大写，多单词时每个单词用下划线分开.如：XXX_YYY_ZZZ

常量

1.常量表示不能改变的数值。
 2.java中常量的分类：
  (1)整数常量：所有整数。
  (2)小数常量：所有小数。
  (3)布尔型常量：只有两个数值,true和false.
  (4)字符常用量：将一个数字、字母或符号用单引号标识。如：'4','a','+'。
  (5)字符串常量：将一个或多个字符用双引号标识。
  (6)null常量：只有一个数值null.
 3.对于整数：java有四种表现形式
  (1)二进制：0或1，满2进1。
  (2)十进制：0~9，满10进1。如：23
  (3)八进制：0~7,满8进1。用0开头表示。如：023
  (4)十六进制：0~9,A~F，满16进1。用0x开头表示。如：0x4a2c

进制

1.进制的特点
  (1)二进制：早期由电信号开关演变而来，任何数据在计算机中都以二进制形式存在。
  (2)八进制：将二进制中的三位用一位表示，最大值7。
  (3)十六进制：将二进制中的四位表示一位，最大值15。

  规律：
    进制越大，表现形式起短。
 2.进制的转换
  (1)十进制--->二进制
  原理：对十进制数进行除2运算。
  示例：算6的二进制：6/2（余0），商3/2（余1），（商1）。倒着写便是6的二进制了，即110。
  用函数在控制台输出6的二进制：System.out.println(Integer.toBinaryString(6));
  (2)二进制--->十进制
  原理：二进制乘以2的过程。
  示例：算110的十进制:0*(2的0次幂)+1*(2的1次幂)+1*(2的2次幂)=6
  11111111=255,八位是一字节，最大值是255。
  (3)二进制--->八进制
  如：算001011010的八进制：001(1)-011(3)-010(2)-->132
  (4)十进制--->十六进制
  如：算90的16进制：90-->01011010-->0101(5)-1010(A)-->0x5A
  (5)负数的二进制：
  原理：相反数的二进制取反后加1。
  示例：算-6的二进制：
  0000-0000 0000-0000 0000-0000 0000-0110（6的二进制）
  1111-1111 1111-1111 1111-1111 1111-1001（取反）
  0000-0000 0000-0000 0000-0000 0000-0001（+1）
  -------------------------------------------
  1111-1111 1111-1111 1111-1111 1111-1010 = -6
  函数验证：System.out.println(Integer.toBinaryString(-6));
  结论：负数的二进制最高位都是1。

变量

1.变量：内存中的一个存储区域，该区域有自己的名称和类型，该区域的数据可在同一类型范围内不断变化。
 2.变量的作用：可将不确定的数据进行存储。用来不断地存放同一类型的常量，并可重复使用。
 3.变量的定义格式：
  数据类型  变量名 = 初始化值
  如：int x = 10;
 4.理解：变量就如同数学中的未知数。
 5.使用变量注意：
  变量的作用域(在一对{}之间有效)
  初始化值
 6.java是强类型语言，对每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
   (1)数据类型
    |--基本数据类型
    |--数值型
    |--整数型(byte,short,int,long)
    |--浮点型(float,double)
    |--字符型(char)
    |--布尔型(boolean)
    |--引用数据类型
    |--类(class)
    |--接口(interface)
    |--数组([])
   (2)注：
   整数默认类型：int，小数默认类型：double.
   取值：
    byte:-128~127
    short:-32768~32767
    char:0~65535

类型转换

1.自动类型转换也叫隐式类型转换
   强制类型转换也中显式类型转换
 2.表达式的数据类型自动提升
   所有的byte型，short型和char型值将被提升到int型
   如果一个操作数是long型，计算结果就是long型。
   如果一个操作数是float型,计算结果就是float型。
   如果一个操作数是double型，计算结果就是double型。

class  VarDemo{public static void main(String[] args) {//定义变量的格式：//数据类型  变量名 = 初始化值；//定义一个int类型变量。取值为4；int x=4;System.out.println(x);x=10;                     //再定义一个x=10，原来的4就没有了System.out.println(x); //演示其他数据类型。byte b=2;//byte是字节，范围是-128~127;//byte b1=128; 运行后提示 错误：可能损失精度。short s=30000;//short是短整型，范围是-32768~32767；long l=4l;//用l标识下 是long类型float f=2.3f;//小数默认是double 要用float存后面加个f；double d=34.56;char ch='4';//char是字符型，将一个数字字母或者符号用单引号标识。char ch1='a';char ch2='+';char ch3=' ';boolean bo=true;//布尔型就2种；boolean bo1=false;System.out.println("hello world");System.out.println(Integer.toBinaryString(6));//十进制转成二进制,6的二进制是110；System.out.println(0x3c);//输出的是十进制60；}}

 

运算符

1.转义字符，通过\来转变后面字母或者字符的含义。

         \n：换行

         \b：退格，相当于backspace键。

         \r：按下回车键。windows中，回车符是\r\n.

         \t：制表符，相当于tab键。

         \":双引号

        \\:斜线

        \':单引号

   注：windows中，回车符由两个字符表示：\r\n.

下面是转义字符个人应用程序

class OperateDemo {public static void main(String[] args) {int x=4270;x=x/1000*1000;System.out.println(x);//x是整型int，其4270/1000取其整型结果4;所以输出为4000;int a=3,b;b=++a;System.out.println("a="+a+",b="+b);//结果为a=4,b=4System.out.println("hello world");System.out.println("hello java");System.out.print("hello world");System.out.println("hello java");//ln是结果后换行，所以该结果是hello worldhello java;/*转义字符：通过\来转变后面字母或者符号的含义。\n:换行。\b:退格。相当于backspace。\r:按下回车键。在windows系统，回车符是由两个字符来表示\r\n。\t:制表符。相当于tab键。*/System.out.println("hello \n world");System.out.println("\"hello world\"");//转义字符要加在被转义的字符前面有效；该结果输出为“hello world”System.out.println(4>=3);}}

 

 2.赋值运算符：
  (1)符号：=    +=   -=   *=   /=    %=
  (2)示例：
  int x = 3;//把右边赋给左边
  x += 4;//把左右两边的和赋给左边==>x=x+4
  (3)s=s+2和s+=2的区别
  s=s+2 ;//编译失败，因为s会被提升为int类型，运算后结果还是int型。无法赋值给左边的short 类型。
  s+=2;//编译通过，因为+=运算符在给s赋值时，自运完成了强制转换操作。
 3.比较运算符：
  符号：==,!=,<,>,<=,>=,instanceof

          ==   相等于   4==3  ->   false

          !=    不等于   4!=3   ->   true

          <   小于     4<3   ->   false

          >   大于     4>3   ->   true

         <=  小于等于4<=3  ->  false

         >=  大于等于4>=3  ->  true

        instanceof 检查是否是类的对象 “Hello” instanceof String  -> ture

  注意：比较运算符结果都是boolean型。

下面是简单赋值运算小程序

class OperateDemo2 {public static void main(String[] args) {System.out.println(false^false);//运行结果falseSystem.out.println(~6);//运行结果-7//1，通过第三方变量。int n = 3,m =8;//要求把两个整数变量进行互换int temp;temp = n;n = m;m = temp;System.out.println("n="+n+",m="+m);//运行结果n=8,m=3//2，不通过第三方变量。//11 = 3 + 8;//3 = 11 - 8;//8 = 11 - 3;int a = 3,b =8;//如果a和b的值非常大，容易超出int的范围。a = a + b;b = a - b;a = a - b;System.out.println("a="+a+",b="+b);//运行结果a=8,b=3//3,不通过第三方变量。异或运算的做法。int x =3, y = 4;x = x ^ y;y = x ^ y;//(x ^ y) ^ y = x;一个数异或2次，还是这个数。x = x ^ y;//(x ^ y) ^ x = y;System.out.println("x="+x+",y="+y);//运行结果x=4,y=3System.out.println(!!true);//运行结果true}}

 4.逻辑运算符：
  &  与       false&true  ->  false 无论左边是true是false，右边都运算

        |   或          false|true   ->  true 两边都参与运算

        ^   异或       false^true   ->  true  当两边都是true时，结果为false

        !    非           !true      ->  false

        && 与短路    false&&true -> false 当左边为false时，右边不运算。

        ||  非短路    false||true  ->  true当两边都为true，右边不运算。

  注：逻辑运算符用于连接boolean类型的表达式。

 5.位运算符：  
  <<    左移           3 << 2 = 12 --> 3*2*2=12//就是乘以2的移动的位数次幂

        >>    右移           3 >> 1 = 1 -->3/(2的1次幂)=1//就是除以2的移动的位数次幂

        >>> 无符号右移      3>>>1 = 1 -->3/2=1//无论最高位是什么，右移后，都用0补空位

        &     与运算        6 & 3 = 2      就是2进制的真假运算。

        |       或运算         6 | 3  = 7     

        ^       异或            6 ^ 3 = 5   

        ~       反码             ~6 = -7      

  注：7^4^4=7;
   一个数异或同一个数两次，结果还是那个数，
   此方法可用来加密和解密数据。

下面是使用逻辑运算和位运算关于进制转换的小程序：

class OperateDemo3 {public static void main(String[] args) {int num =60;//该程序是获取60的16进制表现形式。//获取60的最低4位，通过&15；同理8进制&7然后>>>3，2进制>>>1,&1。int n1 = num & 15;//n1的结果是12；System.out.println((char)(n1-10+'A'));//要获取下一组4位，将60右移4位。int temp = 60 >>> 4;//这里用无符号右移是防止负数一般右移最高位一直加1.//对temp的值进行最低4位的获取。int n2 = temp & 15;//n2结果是3；System.out.println(n2);/*0-9 'A' 'B' 'C' 'D' 'E' 'F'     65  66  67  68  69  70 10  11  12  13  14  15  12 - 10 = 2 + 'A' = (char)67;*/int x = 1,y;y =  (x>1)?100:200;System.out.println("y="+y);//结果是200，满足条件则100，不满足则200。}}

 6.三元运算符：
  (1)格式：(条件表达式 )? 表达式1 :表达式2
  若条件为true,运算结果为表达式1；
  若条件为false,结果为表达式2;
  (2)示例：
  int x=1,y;
  y=(x>1)?100:200;

08.注释

 1.注释的三种方式
  (1)//用于单行注释
  (2)/*
  用于多行注释
  */
  (3)文档注释
  /**
   * java特有的注释方式，用于多行注释，可被javadoc工具解析
   */
 2.注释的两个作用：
  (1)注释文档，提高代码的阅读性。
  (2)调试程序，将错误语句注释掉。

 

程序流程控制

if语句（判断题）

(1)三种格式：
   if（条件表达式）{执行语句;}
   if（条件表达式）{执行语句;}else{执行语句;}
   if（条件表达式）{执行语句;}else if{执行语句;}else{执行语句;}
(2)注：
   if else的简写格式：变量 = (条件表达式)?表达式1：表达式2;
if语句的典型使用：

class IfDemo {public static void main(String[] args) {int x = 1;if(x>1){System.out.println("yes");}/*if else 结构 简写格式： 变量=（条件表达式）？表达式1:表达式2;三元运算符：好处：可以简化if else代码。弊端：因为是一个运算符，所以运算必须有一个结果。int a=9,b;b=(a>1)?100:200;if(a>1)b=100;elseb=200;*/int n=3;if(n>1)System.out.println("a");else if(n>2)System.out.println("b");else if(n>3)System.out.println("c");else System.out.println("d");//运行结果aint y=3; if(y>1)System.out.println("a"); if(y>2)System.out.println("b"); if(y>3)System.out.println("c");else System.out.println("d");//运行结果a   b   d System.out.println("over");}}

if语句的题目：

 

class IfTest {public static void main(String[] args) {//需求1：根据用户定义的数值不同，打印对应的星期英文。int num=1;if(num==1)System.out.println("Monday");else if (num==2){System.out.println("Tuesday");}elseSystem.out.println("no");//需求2：根据用于指定月份所属的季节。//3，4，5，春季 6，7，8，夏季 9，10，11秋季 12，1，2 冬季int x=4;if(x==3||x==4||x==5)System.out.println(x+"月份"+"春季");else if (x==6||x==7||x==8)System.out.println(x+"月份"+"夏季");else if (x==9||x==10||x==11)System.out.println(x+"月份"+"秋季");else if (x==12||x==1||x==2)System.out.println(x+"月份"+"冬季");elseSystem.out.println(x+"月份不存在");int y=7;if(y>12||y<1)System.out.println(y+"月份不存在");else if (y>3&&y<=5){System.out.println(y+"月份"+"春季");}else if (y>=6&&y<=8){System.out.println(y+"月份"+"夏季");}else if (y>=9&&y<=11){System.out.println(y+"月份"+"秋季");}elseSystem.out.println(y+"月份"+"冬季");}}

switch语句（选择题）

(1)格式：
  switch（表达式）
  {
   case取值1：
    执行语句;
    break;
   case取值2：
    执行语句;
    break;
   ......
   default:
    执行语句;
    break;
  }

 (2)switch语句特点：
 
  switch语句选择的类型只有四种：byte,short,int,char
  case与default没有顺序，先执行第一个case,没有匹配的case,执行default.
  结束switch语句的两种情况：
        遇到break;
        执行到switch语句结束。
  如果匹配的case或者default没有对应的break,那么程序会继续向下执行，运行可执行的语句，
  直到遇到break或switch结尾结束。
  (3)if和switch语句很像，什么时候用哪个语句呢？
 
  如果判断的具体数值不多，而且符合byte,short,int,char这四种类型，些时用户switch效率较高。
  对区间判断，对结果为boolean类型判断，使用if.

 

switch语句的小应用：

class SwitchDemo {public static void main(String[] args) {int x=2;switch (x)//被选择的表达式的值只接受byte short int char{case 4:System.out.println("a");break;case 6:System.out.println("b");break;case 2:System.out.println("c");break;default:System.out.println("d");break;//输出结果为c}int a=4,b=2;char ch='+';switch (ch){case '-':System.out.println(a-b);break;case '+':System.out.println(a+b);break;case '*':System.out.println(a*b);break;case '/':System.out.println(a/b);break;default:System.out.println("非法");//输出结果为6}System.out.println("Hello World!");}}