一、什么是java语言

---  一种面向对象的语言

        ··· 编写程序的开始就是编写类的开始 class 用于定义类；

--- 一种与平台无关的语言，必须程序运行的解释环境

        ··· 真正的运行步骤为javac编译——java解释执行

--- 一种健壮【鲁棒性】的语言，吸收了C/C++语言的优点，但是去掉了影响程序健壮性的部分，例如指针、内存的申请与释放等。

常见错误

1、使用临时变量，java要求必须是先定义后使用，必须是先赋初值后使用

int k;
System.out.println(k);

2、目前的要求：将所有的程序都必须写在方法的内部，不能卸载方法外

public class Test{
    int res=0;
    for(int k=1;k<101;k++){
        res+=k;
    }
    System.out.println("1+2+3+...+100="+res)
}

java的三种核心机制

JAVA语言包含三种核心机制：java 虚拟机、垃圾收集机制和代码安全检测。

Java虚拟机 JVM

--- java虚拟机可以理解成一个以字节码为机器指令的CPU

--- 对于不同的运行平台，有不同的虚拟机

--- java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”

垃圾收集机制

--- 不再使用内存空间回收—垃圾回收

--- 在C/C++等语言中，由程序员负责回收无用内存

        java语言消除了程序员回收无用内存空间的责任，它提供了一种系统级线程跟踪存储空间的分

代码安全性检查

java代码的目标运行环境在于网络，java以牺牲执行性能为代价换取了高安全性

java中标识符

--- 字母（Unicode编码字符集）、数字、下划线和$符构成，不允许数字打头

        ··· 严格区分大小写

        ··· ISO8859-1

        ··· GB2312和GBK【GB8030】

        ··· Unicode统一编码字符集

                ·· 由于_和$有特殊含义，一般不建议用户直接使用

                ·· 不建议使用中文命名

--- 不允许使用保留字（goto const）和关键字（public class static...）

--- 长度没有限制

编码规范

--- 类名首字母大写，大写字母分词   建议名词。例如UserName或者MingZi

--- 方法名称首字母小写，大写字母分词

--- 变量名称首字母小写，大写字母分词

--- 包名称全小写，使用域名反转的方式定义

在平常的练习中，我们应该遵循SUN的基本规范；项目开发中要求遵循ali发布的规范。在我们进入初入公司时，首先应该考察公司的编码规范。

Java是一种先编译后解释执行型语言

Java语法基础

--- Java大小写敏感。比如HelloWorld和Helloworld是不一样的

--- 包名Package是公司、组织、个人的域名的反转，一般是英文字母。英文字母必须是小写。

        ··· 包名称可以认为是一个名空间

        ··· 例如百度的网址为baidu.com，定义包名称为com.baidu

--- 类名ClassName和方法名称采用驼峰命名，例如StudentName

--- Java源文件的文件名必须和文件中公共public类名称一样

public class Hello{     //公共类名称为Hello，则对应的文件名称必须为Hello.java

}

--- 关键字中所有字母都为小写。关键字不能用作变量名，方法名，类名，包名和参数。

Java是一种自由格式的语言，可以用任意个空格、制表符、换行符隔开每一个词

System.
out.
println
("Counted " + count + "chars. " );

同时也允许将多行代码写在一行上，注意使用分号隔开。所有的语句末尾以分好“:”收尾。

for(int i=0;i<10;i++){cc++;dd++;}

java中空语句

;

常见的变成错误

1、初步学习阶段，应将所有的程序都必须写在main方法内部，不能写在main方法以外；

2、使用临时变量时，java要求必须是先定义后使用，必须是先赋初值后使用。

Java标识符

标识符可从一个字母（Unicode编码字符集）、下划线“_”或美元符号“$”开始，随后也可跟数字、字母、下划线或者美元符号。

标识符区分大小写，没有长度限制，可以为标识符取任意长度的名字

标识符不允许使用保留字。关键字对java编译器有特殊的含义，它们可标识数据类型名或者程序构造construct名，java语言中的保留字均用小写字母表示。

变量

变量是java程序中的基本存储单元，它的定义包括变量名、变量类型、和作用域这些部分。

例如 int k=100; 其中 int 是数据类型，k 是变量名

变量名称：在一个main方法内部不允许出现多个同名称的变量

--- java要求见名知意，例如username，但是xm（姓名）则不建议使用

变量类型

        --- java属于强类型编程语言，变量类型一旦生命，则不能进行修改

        --- 数据类型可以决定变量所需要的存储空间大小和对应的处理逻辑

int k;      //声明一个变量，类型为整形，变量名称为k
int k=100;  //声明变量的同时进行初始化 
k=12.345;   //语法错误，因为已经声明了类型为整形，但是12.345不是整数 
d=123;      //语法错误，因为Java语法要求对于变量必须是先定义后使用

作用域是指变量的有效范围，一般是所在的花括号范围内

public static void main(String[] args){ 
    { 
        System.out.println(k);//错误1：要求临时变量必须是先定义后使用，必须是先赋初值后使 用 
        int k=100; 
        System.out.println(k);
    }
    System.out.println(k);//错误2：因为k定义在{}内部，所以k只在上面的{}分为内有效，离开了 {}则失效，{}外引用k则报错 
}

public static void main(String[] args){
    int k=99; 
    { 
        System.out.println(k); 
        int k=100; //错误：因为Java是强类型编程语言，所以在{}外已经声明了k的类型，在k的有效 范围内不允许重新声明。这里可以修改为k=100; 
        System.out.println(k); 
    }
    System.out.println(k); 
}

 Java是强类型语言

每个变量有类型，每个表达式有类型，而且每种类型都是严格定义的

Java编译器对所有的表达式和参数都要进行类型相容性的检查，以保证类型是兼容的

short k1=123; 
int k2=k1;//没有错误

任何类型的不匹配都将被报告为错误而不是警告。在编译器完成编译以前，错误必须被改正过来

String s1="123";//字符串类型 
int k1=s1;//语法报错

基本类型（原生类型）

 整形有4种：byte字节整、short短整、int整、long长整

--- java中的数据类型采用的是补码的存储方式

        计算机中存储数据有3种不同的方式，分别是原码、反码和补码

 byte：1B（8b）， -123到127

byte k = 100;//语法正确100在指定范围内 
byte kk = 130;//语法报错，因为130超出byte的存储范围限制 
//这里的面试点在常量池

short：2B，-32768到32767

int：4B，-2147483648到2147483647

long：8B，-9223372036854775808到9223372036854775807

如果需要使用具体的上下限取值，可以通过包装类中的常量进行使用

System.out.println(Integer.MAX_VALUE); 
System.out.println(Integer.MIN_VALUE);

 十进制整数。如123，－456，0

 八进制整数。以0开头，如0123表示十进制数83，－011表示十进制数－9。

 十六进制整数。以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18

        a-->10 b-->11 c-->12 d-->13 e-->14 f-->15

 二进制整数，以0b或0B开头，例如0b10110010

int k1=123; 
int k2=0123; 
int k3=0x123; 
int k4=0b100101; 
System.out.println(k1+"t"+k2+"t"+k3+"t"+k4);//具体输出时，系统会自动将k2转换为10进制输出

 可以通过包装类中提供的方法将十进制数转换为2、8和16进制

int k = 123; 
String ob=Integer.toBinaryString(k);//将十进制数转换为2进制的字符串 
System.out.println(ob); //1111011 

String oo=Integer.toOctalString(k); 
System.out.println(oo); //173 

String oh=Integer.toHexString(k); 
System.out.println(oh);//7b

 整数类缺省为int类型，如在其后有一个字母“l或者L”表示一个long值

        123系统会自动识别为int类型

        123L 或者 123l 系统自动识别为 long

浮点数类型 

float单精度、double双精度

--- float是4B，可以保证小数点后6位有效精度和第7位的部分精度 。e38

        ··· 32位，1个符号位，23个尾数位，8个指数位

        ··· 1.4E-45到3.4028235E38

--- double是8B，可以保证小数点后15位有效精度和第16位的部分精度。e308

        ··· 64位,1个符号位,52个尾数位,11个指数位

        ··· 4.9E-324到1.7976931348623157E308

--- 浮点数是无法精确存放的，原因在于将浮点数转换为补码时的限制。除非使用BigDecimal

double res = 0; 
for (int i = 0; i < 10; i++) 
    res += 0.1; 
System.out.println(res); //0.9999999999999999

--- 针对浮点数则不能使用等值判断

 --- 指数位Exponent：用于存储科学计数法中的指数数据，单精度为8位，双精度为11位。用指数部分的值（8位/11位unsigned）的值减去偏移附加值得到该数实际的指数。例如值为200，实际指数为73=200-127。

--- 尾数部分Mantissa

double d = 0.1d; 
long l = Double.doubleToLongBits(d); //long类型和double类型都是64位的,他们的内存大小一 样,这个函数的做法就是把double对应的内存结构复制到同样大小的long类型变量的内存结构中.返回这个long值
System.out.println(t.getLongBits(l));

样例17.625在内存中的存储为：

--- 首先要把17.625换算成二进制： 10001.101

        ··· 整数部分：除以2，知道商为0，余数反转

        ··· 小数部分：乘以2，知道乘位为0，进位顺序取。（即：乘2取整法）

 --- 再再将10001.101右移，直到小数点前只剩1位，1.0001101*2^4 ，右移动了四位。

底数：因为小数点前必为 1 ，所以 IEEE 规定只记录小数点后的就好。所以，此处的底数为

0001101

指数：实际为 4 ，必须加上 127 （转出的时候，减去 127/1023 ），所以为 131 。也就是

10000011

 --- 符号：因为是正数，所以是0

--- 综上所述，17.625在内存中的存储格式是：01000001 10001101 00000000 00000000

表示方法：

--- 十进制数形式。由数字和小数点组成，且必须有小数点，如0.123, 1.23, 123.0

--- 科学计数法形式。如：123e3或123E-3，其中e或E之前必须有数字，且e或E后面的指数必须为整数

--- f或者F表示float，而d或者D代表double。例如123f或者123.45D，系统默认为double类型

字符类型 char

``` 字符类型的变量可以当作整数使用

``` char c='a'; 注意：这里使用的是单引号，不是双引号，单引号中只能包含一个字符 

        ```需要记忆： '0' < 'A' <'a'

 布尔类型  boolean

 boolean数据类型有两种文字值：true真和false假

在Java编程语言中boolean类型只允许使用boolean值，在整数类型和boolean类型之间无转换计算  

基本数据类型转换 

小转大自动转换  

byte b1=123; 
long k1=b1; 
double kk=k1; 
System.out.println(kk); 
long kk = 123456L; 
float ff=kk; //没有错误。float 4B long 8B

 大转小需要强制转换

double dd=123.567; 
long kk=(long)dd; 
System.out.println(kk);

int k=100; 
char cc=(char)k; //强制类型转换：窄化操作 
char k='d'; 
System.out.println((int)k); 
boolean bb=true; 
System.out.println((int)bb);//因为boolean类型和数值类型之间没有任何对应关系，
//所以这里的强转会报语法错误

float f1=123.456;
/*语法报错，因为系统默认带小数点的数据为double类型，
所以123.456是double 类型的数据，而声明f1为float，所
以这里需要进行数据类型转换或者进行特殊声明。如果浮点
数转换为整数 是直接截断小数部分。*/

float f1=(float)123.456; 
float f1=123.456f; 
/*数字末尾的f类似于数字末尾的L，用于进行数据类型的说明，f
/F表示这是一个 float类型的数据 d/D表示是一个double类型的数据*/

常量

表达式  

```算术运算符 +、-、*、/、%、++、--

```关系运算符 >、<、>=、<=、==、!=  

```逻辑运算符 &&、 ||、 !。注意：逻辑计算支持短路操作 

```位运算符 &、|、^、~、<< 、 >>、>>>

```赋值运算符 =，+=，―=，*=，/= 

```三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;  

算术运算符 +、-、*、/、%、++、-- 

 

+-*/

整除：参与运算的双方都是整数 10 / 3 = 3 而不是 3 . 33333

如果是 10 . / 3 = 3.333 ... 这里由于 10 . 是浮点数，则 3 会自动转换为大类型并参与计算，所以最终是 10 . 0 / 3.0

的计算结果

计算次序为先乘除后加减，如果优先级一致，则自动从左向右进行计算 10 + 2 * 5 = 20

/ 除法分母不能为 0 ，否则出错

% 求余（取模） 10 % 3 = 1 实际就是 10 除以 3 求余数

double k = 10.12 ;

System . out . println ( k % 3 );

输出： 1 . 1199999999999992 应该返回值为 1 . 12 ，由于浮点数不能精确存放，所以返回值是一个类似值

double d1 =- 10.12 ;

double res = d1 % 3 ;

System . out . println ( res );

输出值为 - 1.1199999999999992 求余计算中符号位不参与计算

double dd = 12.45 ;

System . out . println ( dd % 3.1 ); //0.049999999999998934

++ 和 -- 是单目运算符

i ++ 等价于 i = i + 1 , i -- 等价于 i = i - 1

以 ++ 为例写法有 2 个： i ++ 或者 ++ i 考核题目

考核题目 2

关系运算符 > 、 < 、 >= 、 <= 、 == 、 !=

用于判断两个数据之间的大小关系，计算结果为 boolean ，如果成立返回为 true ，否则为 false

浮点数的比较

i ++ 是先获取 i 的值，然后再对 i 加 1

int age = 100 ;

System . out . println ( age ++ ); 输出为 100

System . out . println ( age ); 输出为 101 , 因为上面进行加 1

++ i 是先对 i 加 1 ，然后再获取 i 的值

int age = 100 ;

System . out . println ( ++ age ); 输出 101 , 先加 1 然后获取值

System . out . println ( age ); 输出 101

关系运算符 >、<、>=、<=、==、!= 

用于判断两个数据之间的大小关系，计算结果为boolean，如果成立返回为true，否则为false 

double d1=10;

System.out.println(d1>3); 返回 true

== 和 = 的区别 :

k=100; 这是赋值运算符，意思是将 = 右边的计算结果储存在 = 左边的变量中

k==100 这是比较计算符，意思是判断 k 是否值为 100 ；如果是则返回 true ，否则 false

!= 意思是判断是否不等于，表示如果相等时返回 false ，否则返回 true

k!=100 不等于判定，如果 k 值为 100 则返回 false ，如果 k 值不是 100 则返回 true

由于浮点数无法精确存放，所以判断 k==1.0 这个写法是错误的

正确写法： a-b 的绝对值小于 1e-6

Java 提供了一个工具类 Math ，其中包含一个 abs() 的方法实现求绝对值

Math.abs(d1-1)<1e-6 判断浮点类型的变量 d1 的值是否为 1

 

浮点数的比较 

double res = 0; 
for(int i=0;i<10;i++) 
    res=res+0.1; 
if(Math.abs(res-1)<1e-6) //|res-1|判断是否小于10的-6次方 
    System.out.println("计算结果为1"); 
else
    System.out.println("计算结果不为1");

 逻辑运算符 &&、 ||、 !

表达多个条件之间的关系。 

``` &&:与运算，含义是两个条件必须同时成立，可以翻译为并且  

``` ||：或运算，含义是两个条件中成立一个即可，可以翻译为或者 

赋值运算符 =，+=，-=，*=，/=，%=  

int k=100; 含义是将 100 赋值存储在 k 对应的存储单元中

k=k+3 可以简写为 k+=3 -= */ /= 类似

结构化编程 

指导思想 

自顶向下、逐步求精、模块化 

最后

以上就是心灵美灰狼为你收集整理的JAVA的初步认知 一、什么是java语言常见错误java的三种核心机制java中标识符Java是一种先编译后解释执行型语言Java标识符变量 Java是强类型语言基本类型（原生类型） 整形有4种：byte字节整、short短整、int整、long长整浮点数类型 字符类型 char  布尔类型  boolean基本数据类型转换 复合数据类型常量表达式  算术运算符 +、-、*、/、%、++、-- 关系运算符 >、<、>=、<=、==、!=  逻辑运算符 &&、 ||、 !赋值运算符 =，+=，-的全部内容，希望文章能够帮你解决JAVA的初步认知 一、什么是java语言常见错误java的三种核心机制java中标识符Java是一种先编译后解释执行型语言Java标识符变量 Java是强类型语言基本类型（原生类型） 整形有4种：byte字节整、short短整、int整、long长整浮点数类型 字符类型 char  布尔类型  boolean基本数据类型转换 复合数据类型常量表达式  算术运算符 +、-、*、/、%、++、-- 关系运算符 >、<、>=、<=、==、!=  逻辑运算符 &&、 ||、 !赋值运算符 =，+=，-所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。