java 基础---标识符，作用域

1，  java代码的位置;

a)         java代码都应该放在一个class类里面。

2，  java是严格区分大小写的。

a)         num和NUM是两个变量

3，  java是一种自由格式的语言，

a)         代码分为结构定义语句和功能执行语句

                         i.              定义一个类，一个方法。

                       ii.              赋值，声明变量都是执行语句，表示的是一个具体的动作。

b)        功能执行语句的最后必须用分号结束。

 

标识符：

标识符（实质就是包、类、方法、参数和变量的名字名称）26个字母，下划线，和$数字组成。

数字不能开头

是大小写区别对待的, 且无最大长度

标识符不能是关键字，但是它可包含一个关键字作为它的名字的一部分

例如：thisone是一个有效标识符，但this却不是，因为this是一个Java关键字

常量：从程序开始运行到结束都不变的量。在java中使用关键字final来声明一个常量。

       数值常量：有四种表现形式：十进制，十六进制（0x12），八进制（012），二进制

       布尔常量

字符常量中的”\”是转义字符，为了表示那些不可见的字符。

       \r,表示接受键盘输入，相当于按下了回车键

\n,是换行。

\b,是退格键

\t,是制表键 相当是TAB键

\\,是斜杠“\“

\",是双引号

\',是单引号

字符串常量

null常量：只是一个值。表示对对象的引用是空。  注意“ “！=null；

变量

       变量是用来保存数据的.

变量实质就是内存中的存储空间，空间中的值是未知的。

       作用就是不断的存放同一类型的常量，并可以重复使用。

       变量三要素：数据类型，变量名，值。

       每个声明的变量都需要分配一个类型。

 

实例变量 – 与对象（实例）有关

类变量（静态变量） - 与类有关

局部变量 – 与栈帧有关

 

定义格式：

              数据类型 变量名 = 初始化值；变量也可被定义为方法参数或构造函数参数。

 

变量必须先声明，后初始化（即赋初值），最后才能使用

当任何原始类型(如boolean, byte, short,char,int,long,float或double类型) 的变量被声明时，存储器空间也同时被分配。使用非原始类型(如String或class)的变量的声明不为对象分配存储器空间。

 

使用class类型声明的变量不是数据本身，而是数据的引用(reference)。

a）  基本数据类型(八种)      1字节=8位    JAVA 整数默认是int。小数默认是double。

byte, short, int,long,float,double,char,boolean

• byte占用一个字节，数字大小为-2⁷—2^7-1   字节的本质就是一定范围的int数字。
• short占用两个字节，数字大小为-2¹⁵—2^15-1
• int占用四个字节，数字大小为-2³¹—2^31-1
• long占用八个字节，数字大小为-2⁶³—2^63-1   需要通过l来明确类型
• float占用四个字节，数字大小为1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38
  • 需要在值后面通过f来明确float类型
• double占用八个字节，数字大小为4.9E-324~1.7E+308, -4.9E-324~-1.7E+308
• char占两个字节，数字大小为0—2^16-1   （0~65535）

Boolean占一个字节，其取值只有两个，true和false

 

b）  引用数据类型    所谓引用数据类型，实际上表示的是一个对象的地址（非真实的内存地址，但能够通过这个地址访问到相应的对象）

                 没有对象引用的情况下，仍有可能使用对象，这样的对象称作”匿名”对象。

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

数组   

类    

接口

c) 引用数据类型的赋值

int x = 7;

     int y = x;

     String s = “Hello”;

     String t = s;

    四个变量被创建：两个原始类型 int 和两个引用类型String。x的值是7，而这个值被复制到y；x 和 y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。

至于变量 s 和 t，只有一个String 对象存在, 它包含了文本”Hello” ，s 和 t均引用这个单一的对象。

C）术语描述：

-          类------在Java编程语言中定义新类型的一种途径。类声明可定义新类型并描述这些类型是如何实现的。有许多关于类的其它特性还未讨论。

-          对象------一个类的实例。类可被认为是一个模板------你正在描述一个对象模型。一个对象就是你每次使用new创建一个类的实例的结果。

-          引用类型------一个用户定义类型, 它可引用类、接口和数组。

-          成员------构成一个对象的元素之一。这个词也被用作定义类的元素(elements)。成员变量(member variabl)、实例变量(instance variable)和域(field)也经常被互换使用。

 

按位置分或作用域：

成员变量：也叫类变量。定义在类中，作用于整个类，随着对象的加载而加载，在内存中有默认的初始化值。

              成员变量是对象所应有的，代表对象的属性值，如：自行车对象的颜色，材料。

局部变量：

1，  局部(local)变量是在一个方法内定义的变量, 也被称作自动（automatic）、临时（temporary）或栈（stack）变量

2，  一个方法被执行时, 局部变量被创建；当一个方法被终止时, 局部变量被清除

3，  局部变量必须使用之前初始化, 否则编译时将出错

 

类型转化（这里只针对原始数据类型）

a）  向上转型：（自动类型提升或隐式类型转换）表达式的数据类型自动提升要满足两个条件;

两个类型之间是兼容的

接收类型的范围比原类型的大.

byte/short/char之间不互相转换（没有必要，默认是int）

 byte, short, char 之间参与运算后就自动提升为int。

若一个操作数是long型，计算结果就是long型。

如果一个操作数是float型，计算结果就是float

如果一个操作数好是double，计算结果就是double。

多种类型的数据混合运算时，会自动将所有类型转换为最大表数范围的那种类型之后再运算   System.out.println(“”+’a’+1) String 类型是最大范围的。; System.out.println(‘a’+1); 字节的实质就是数字，int的类型的和type类型中int的范围是最大的。 就是一个实例。

 

String是类类型,可以象普通类型一样。

变量可以直接通过赋值的方式进行声明,字符串使用””括起来,两个字符串之间用”+”相连,

任何数据类型碰到String类型的变量或常量之后都向String类型转换.

 

分析System.out.println(‘a’+1)与System.out.println(“”+’a’+1)的区别。

字符因为有ASCII的存在，每个字符都有对应的数字   任何值和字符串相加都转变成字符串。

public class Demo23 {

    public static void main(String[] args) {

       person re = new person("hahah");

 

       String f = " liuhonglaing ";

       System.out.println (re + f);//结果是person类继承Object类,打印的是toString定义的return值。

    }

}

 

class person {

    String name = "er";

 

    person(String name) {

       this.name = name;

    }

}

 

b）强制转换：（显式类型转换）       表数范围大的类型转换为表数范围小的数据类型时，需要进行强制类型转换

使用（类型）的方式，将一个占空间较大的值转化为一个占空间较小的值，有可能损失精度。

                     一般用于对小数保留正数。

运算符：就是用变量或常量进行运算时，需要用到的符号。

       有十种：算术，关系，逻辑，位运算，赋值，三元，逗号，字符串，转型。

1，  算数运算符：

+    能够进行String对象的链接并生成一个新的String：

-      变量被自动升级为一个较长的形式（如：int至long的升级）

              %：取余数。

              左边小于右边结果是左边。

              左边等于右边结果是0。

              负数取模只看左边。

 

              整数%2的结果非0即1.可以用于判断切换。

       2，赋值运算符：赋值运算符是一元运算符，会自动转换动作。

              += : 将左右两边的和赋给左边。

              ++：b=a++;先将a值赋值给b，然后a在自增。

 b=++a:先对a进行自增，然后将自增后的值赋给b。

 

              x+=3;// x = x+3;

              但是赋值运算符会自动转换动作。

 

       3，比较运算符：

              该运算符的结果肯定是boolean类型的值。

 

       4，逻辑运算符：

              &    |   ^   !   &&   ||

              用于连接两个boolean类型的表达式。

 

              &：两边的表达式都会参与运算。

              &&：当左边为false时，右边不参与运算。

 

              |：两边的表达式都会参与运算。

              ||：当左边为true时，右边不参与运算。

             

              短路现象：在进行逻辑运算时，如果一个表达式我们已经可以准确无误地确定它的值，将不再计算表达式剩余的部分

 

public class TestAnd

{

   public static void main(String[] args)

   {

       int x=0;

       int y=3;

       if(x!=0 && y==y/x)

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

   }

}

上面例子中，由于if语句的判断条件中的第一个布尔表达式是不成立

的，程序就不会判断第二个布尔表达式的值，这就是“短路”。如果两

个表达式之间用“&”来连接，如果正好碰到上面所示的特殊情况，程

序运行时就会出错

 

              &:

              true & true = true;

              true & false = false;

              false & true = false;

              false & false = false;

              两边都true时，结果为true

              否则结果为false。

 

              |：

              true | true = true;

              true | false = true;

              false | true = true;

              false | false = false;

              只要一边为ture时，结果为ture。

              否则，结果为false。

 

 

^：异：比较两边不同异或（两者相等即为0；两者相异即为1）：

1异或1=0

0异或0=0

1异或0=1

0异或1=1

              true ^ true = false;

              true ^ false = true;

              false ^ true = true;

              false ^ false = false;

^:和或很雷同，只有两边为true结果是false。

 

              两边相同的时候，结果是false。

              两边不同的时候，结果是true。

              用于简单的加密

 

！非       判断事物的另一面

 

4，  位运算符：就是二进制位运算。

a)         支持的位运算符是！、&、｜、^， 支持的布尔逻辑运算符是NOT、AND、XOR和OR。每个运算都返回布尔结果。

b)        >>>运算符仅被允许用在整数类型, 并且仅对int和long值有效。如果用在short或byte值上, 则在应用>>>之前, 该值将通过带符号的向上类型转换被升级为一个int。有鉴于此，无符号移位通常已成为符号移位。

移位不会改变变量本身的值。如a>>1；在一行语句中单独存在，毫无意义 。

对于位操作只适用于byte short  int  char  long

 

              <<:可用于乘2的幂运算。左移

对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数。例如：a>>33和a>>1结果是一样的，a>>32的结果还是a原来的数字。

 

              >>:可用于除2的幂运算。右移

              对于long型整数移位时a>>b ，则是先将移位位数b对64取模

x>>1的结果和x/2的结果是一样的，x<<2和x*4的结果也是一样的。总之，一个数左移n位，就是等于这个数乘以2的n次方，一个数右移n位，就是等于这个数除以2的n次方。请思考：如何用程序实现求2的x次方。

 

              >>>:无符号右移：无论最高位是0还是1，空位都用0补。

 

逻辑运算符也可以进行位运算

              &    |   ^     ~

              技巧：可以将1理解true。0理解为false。

              &: 任何数与0&结果都为0，与1&结果为自身

              相等的两数|，|运算的结果才为原数，0|任何数，|结果都为任何数，任何数与1|结果都为1。

              相等的两数^，^运算的结果才为0，0^任何数，^结果都为任何数。

              一个数据^同一个数两次，就得到原数

 

              ~反码  原码-反码-补码-》负数

把原码的0变1，1变0，就得到反码。要得到补码，则先得反码，然后加1。

             我们只知道正整数在计算机里是如何表达，现在我们还知道负数在计

算机里使用其绝对值的补码表达。

 

              操作：

              1，当想要获取一个整数的某几位二进制位。可以将该几位通过右移的形式变成最低位。

              然后通过于对应为多个1的形式进行&运算。

              2，一个数异或一个数两次，还是原值。

      

       6，三元运算符：三元运算符是if else语句的简写格式，要运行就要有数据的运算结果。

              ？ ：    变量 = 条件判断? 表达式1:表达式2,      boolean-exp?value0:value1

              int  x=3,y=5,z;

              z = (x>y)?x:y;

instanceof是Java编程语言特有的运算符

      

生命周期与作用域

a）  变量的额声明周期：在方法被执行的时变量才定义，并初始化赋值，当方法执行完毕后，变量所占的空间会随之释放的这段时间。

b）  变量的作用域范围：就是看变量在哪一级花括号中定义的。所谓变量的作用域，即变量在声明之后，在什么地方可以访问到它

在变量的作用域范围，可以任意的访问变量，但不能重复定义相同名称的变量。

public class TestScope{

    public static void main(String[] args) {

       int x = 12;           

             {

                   int q = 96;  // x和q都可用

              

                   int x = 3;//错误的定义，Java中不允许有这种嵌套定义

                   System.out.println ("x is "+x);

                   System.out.println ("q is "+q);

             }

            q = x;     /* 错误的行，只有x可用， q 超出了作用域范围 */

            System.out.println("x is "+x);     

   }}

 

转载于:https://www.cnblogs.com/liuhongliang1234/p/3430562.html