java基础语法

注释、标识符、关键字

注释

注释并不会执行，是给我们（写代码的人）看的
书写注释是一个非常好的习惯

Java中的注释：
　　　　１.单行注释：可以注释一行文字　
//......
　　　　２.多行注释：可以注释一段文字

/*
......
*/

　　　　３.文档注释：用于生产API文档，配合JavaDoc。

/**
 * @Description 描述功能的参数
 * @Author 说明作者的参数
 *
 *这里的每一行都有*号
 */

标识符

Java所有的组成部分都需要名字。
类名、变量名和方法名都被称为标识符。
！注意点

关键字

数据类型

强类型语言
Java、C、C++
要求变量的使用要严格符合规定，所有变量必须先定义后才能使用。
特点：

　　1. 安全性高，更加严谨
　　2. 速度慢
弱类型语言
Python、VB、JS
对变量的定义、使用没有严格要求

基本类型（primitive）

整数类型：byte、short、int、long

浮点类型：float、double

字符类型：char

布尔类型：boolean

引用类型（reference type）

字节

扩展知识

整数扩展

进制
十进制整数，如：99, -500, 0。
八进制整数，要求以 0 开头，如：015。
十六进制数，要求 0x 或 0X 开头，如：0x15 。

//
int i=10;
int i2=010;
int i3=0x10;
System.out.println(i); //10
System.out.println(i2); //8
System.out.println(i3); //16

浮点扩展

浮点类型ﬂoat, double的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

public static void main(String[] args) {    float f = 0.1f;
   double d = 1.0/10;
   System.out.println(f==d);   //false    float d1 = 2131231231f;
   float d2 = d1+1;    if(d1==d2){
       System.out.println("d1==d2");    }else{
       System.out.println("d1!=d2");  }
}

主要理由：
由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示，其结果只能是接近，但不等于；二进制浮点数不能精确的表示0.1,0.01,0.001这样 10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。
最好完全避免使用浮点数比较 !
大数值：Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

总结：

默认是double
浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
避免比较中使用浮点数
字符扩展
单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示一个字符串。 char 类型用来表示在Unicode编码表中的字符。.
Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536（2的16次方）个字符；

public static void main(String[] args) {    char c1 = 'a';
   char c2 = '中';
   System.out.println(c1);
   System.out.println((int) c1);   //97
   System.out.println(c2);
   System.out.println((int) c2);   //20013 }

转义字符

布尔值扩展

boolean类型（一位，不是一个字节），就是0|1
boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
boolean 类型用来判断逻辑条件，一般用于程序流程控制。

boolean flag = false; 
if(flag){
 // true分支 
}else{
 // false分支 }

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。整型、实型（常量）、字符型数据可以混合运算。
运算中，不同类型的数据先转化为同一类型，然后进行运算。转换从低级到高级（根据容量来看、小数优先级一定比整数高）。

低 ------------------------------------> 高 byte,short,char—> int —> long—> float —> double

转换规则

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

自动类型转换（低->高）

char c1='a';//定义一个char类型
int i1 = c1;//char自动类型转换为int
System.out.println("char自动类型转换为int后的值等于"+i1);  //97
char c2 = 'A';//定义一个char类型
int i2 = c2+1;//char 类型和  int 类型计算
System.out.println("char类型和int计算后的值等于"+i2);  //66

强制类型转换（高->低）

语法格式：(type)var
运算符“()”中的type表示将值var想要转换成的目标数据类
条件是转换的数据类型必须是兼容的。

double x  = 3.14;
int nx = (int)x;   //值为3    char c = 'a';
int d = c+1;
System.out.println(d); //98
System.out.println((char)d);  //b

常见的错误和问题

操作较大的数时，要留意是否溢出，尤其是整数操作时

   int money = 1000000000;  //10亿
   int years = 20;
   int total = money*years;   //返回的是负数
   long total1 = money*years;  //返回的仍然是负数。默认是int，因此结果会转成 int值，再转成long。但是已经发生了数据丢失
   long total2 = money*((long)years);   //先将一个因子变成long，整个表达式发 生提升。全部用long来计算。
   System.out.println(total);
   System.out.println(total1);
   System.out.println(total2);

L和l 的问题

不要命名名字为l的变量
long类型使用大写L不要用小写，防止看成1。

   int l = 2;
   long a = 23451l;
   System.out.println(l+1); //3
   System.out.println(a);   //23451

JDK7扩展

二进制整数
由于我们在开发中也经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型。我们只要以 0b 开头即可。
int a = 0b0101;
下划线分隔符
在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割。
int b = 1_2234_5678;

变量

变量的定义

变量是什么：就是可以变化的量！
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

type varName  [=value] [{,varName[=value]}] ；
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束

int a, b, c;         // 声明三个int型整数：a、b、c 
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值 
byte z = 22;         // 声明并初始化    z
String s = "runoob";  // 声明并初始化字符串    s 
double pi = 3.14159; // 声明了双精度浮点型变量    pi 
char x = 'x';        // 声明变量    x 的值是字符    'x'。

虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则 : monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则: Man, GoodMan
方法名：首字母小写和驼峰原则: run(), runRun()
变量的作用域
三种作用域：

局部变量（lacal variable）：类的方法中的变量。
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
静态变量（类变量： static variable）：独立于方法之外的变量，用 static 修饰。

public class Variable{
   static int allClicks=0;    // 类变量    
   String str="hello world";  // 实例变量
   public void method(){        
       int i =0;  // 局部变量  
   }
}

局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。
在使用前必须先声明和初始化(赋初值)。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public static void main(String[] args) {    
   int i=10; //必须先初始化，否则无法使用
   int j = i+5 ;
   System.out.println(j); }

实例变量

方法外部、类的内部定义的变量。
从属于对象，生命周期伴随对象始终。
如果不自行初始化，他会自动初始化成该类型的默认初始值

public class Test {
      // 这个实例变量对子类可见    
      public String name;    
      // 私有变量，仅在该类可见    
      private double salary;
}

静态变量

使用static定义。
从属于类，生命周期伴随类始终，从类加载到卸载。
如果不自行初始化，他会自动初始化成该类型的默认初始值

public class Employee {    
   //salary是静态的私有变量
   private static double salary;    
   // DEPARTMENT是一个常量
   public static final String DEPARTMENT = "开发人员";     
   public static void main(String[] args){
       salary = 10000;
       System.out.println(DEPARTMENT+"平均工资:"+salary);  
   }
}

常量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;
final double PI=3.14; 
final String LOVE="hello";

运算符

Java 语言支持如下运算符：
算术运算符: +，-，，/，%，++，--
赋值运算符 =
关系运算符: >，<，>=，<=，==，!=，instanceof
逻辑运算符: &&，||，!
位运算符: &，|，^，~ ， >>，<<，>>> (了解)
条件运算符？：
扩展赋值运算符:+=，-=，=，/=

二元运算符

两个操作数

整数运算
如果两个操作数有一个为Long, 则结果也为long
没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

public static void main(String[] args) {    
   long a = 1231321311231231L;
   int b = 1213;    
   short c = 10;    
   byte d = 8;
   System.out.println((a+b+c+d));  
   //Long类型
   System.out.println((b + c + d));
   //Int类型
   System.out.println((c + d));
   //Int类型 
}

浮点运算

如果两个操作数有一个为double, 则结果为double. 只有两个操作数都是ﬂoat, 则结果才为ﬂoat.

public static void main(String[] args) {    
float a = 3.14565F;
   double b = 3.194546464;    float c = 1.3123123F;
   System.out.println(a+b); //double类型
   System.out.println(b+c); //double类型
   System.out.println(a+c); //float类型 }

关系运算符

这里返回的是布尔值

取模运算

也就是求余数的运算

其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

要点：
负数%负数＝负数；
负数%正数＝负数；
正数%负数＝正数；

public static void main(String[] args) {
   System.out.println(9 % 4); //1
   System.out.println(-9 % -4); //-1
   System.out.println(-10 % 4); //-2
   System.out.println(9 % -4); //1 
}

一元运算符

自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数，分为前缀和后缀两种。

public static void main(String[] args) {
   int a = 3;
   int b = a++;   //执行完后,b=3。先给b赋值，再自增。
   int c = ++a;   //执行完后,c=5。先自增,再给b赋值 
}

注意：java中的乘幂处理

public static void main(String[] args) {
   int a = 3^2;    //java中不能这么处理，    ^是异或符号。    
   double b = Math.pow(3, 2);
}

Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

逻辑运算符

逻辑与：&&和&，逻辑或：||和|，逻辑非：！。

public static void main(String[] args) {    
boolean a = true;
   boolean b = false;
   System.out.println("a && b = " + (a&&b)); //false
   System.out.println("a || b = " + (a||b) );//true
   System.out.println("!(a && b) = " + !(a && b)); //true
}

注意：

逻辑与和逻辑或采用短路的方式。
从左到右计算，如果确定值则不会再计算下去。
在两个操作数都为 true时，结果才为true，
但是当得到第一个操作为false时，其结果就必定是false，
这时候就不会再判断第二个操作了。
逻辑与只要有一个为false, 则直接返回false. 逻辑或只要有一个为true, 则直接返回true;

public static void main(String[] args){    
   int a = 5;//定义一个变量；
   boolean b = (a<4)&&(a++<10);
   System.out.println("使用短路逻辑运算符的结果为"+b);
   System.out.println("a的结果为"+a);
}

解析：该程序使用到了短路逻辑运算符(&&)，
首先判断a<4 的结果为false，则b 的结果必定是false，
所以不再执行第二个操作a++<10 的判断，所以a 的值为5。

位运算

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型 (byte)等类型。位运算符作用在所有的位上，并且按位运算。

A = 0011 1100
B = 0000 1101
----------------- 
A&b = 0000 1100
A | B = 0011 1101 
A ^ B = 0011 0001 
~A= 1100 0011

<<左移一位相当于乘2。
>>右移一位相当于除2取商。

【常见面试题：int a=2*8怎样运算效率最快？】 “
解析：

public static void main(String[] args) {    
	System.out.println(2 << 3);	//16
}

用移位运算 int a=2<<3;
a就是2乘以8 最后结果是16 这是最省内存最有效率的方法这个方法确实高效率的。

解释：
2的二进制是10 在32位存储器里面是0000 0000 0000 0010
左移三位后变成 0000 0000 0001 0000 也就是16
在系统中运算是以二进制的形式进行的。
相比来说俩个二进制数相乘运算比移位运算慢一些。
位操作是程序设计中对位模式按位或二进制数的一元和二元操作。
在许多古老的微处理器上，位运算比加减运算略快，通常位运算比乘除法运算要快很多。在现代架构中，情况并非如此:位运算的运算速度通常与加法运算相同(仍然快于乘法运算). 详细的需要了解计算机的组成原理！

扩展运算符

public static void main(String[] args) {    
   int a=10;
   int b=20;
   a+=b; // a = a + b
   System.out.println(a+":"+b); //一样的
}

字符串连接符

“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

//字符串
String s1="Hello 中文!"; 
String s2=1+"";  //转换成String 
//int
int c = 12;
System.out.println("c=" + c);

三木条件运算符

语法格式：

x ? y : z

其中x为boolean类型表达式，先计算x的值，
若为true，则整个三目运算的结果为表达式 y 的值，
否则，整个运算结果为表达式 z 的值。

运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部：

包机制

问题

当定义了多个类的时候，可能会发生类名的重复问题。

解决方式：在java中采用包机制处理开发者定义的类名冲突问题。
就好比我们平时的用电脑，一个文件夹下不能存在同名的文件，我们要是有这样的需求，但是又不想换名字，我们就可以考虑使用新建一个文件夹来存放！在我们的Java中也是这样的。

包的作用

1、把 功能相似或相关的 类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。
同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的。
当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

包语句的语法格式：

package pkg1[．pkg2[．pkg3…]];

以下是一些 Java 中的包：

java.lang-打包基础的类
java.io-包含输入输出功能的函数

创建包

创建包的时候，你需要为这个包取一个合适的名字。
之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包
（unnamed package）中。
一般利用公司域名倒置作为报名；
例子：
www.baidu.com 包名：com.baidu.www

import关键字

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
为了能够使用非本包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

注意
- 如果两个类重名，需要导入对应的包，否则就需要写出完整地址：
  
  com.kuang.dao.Hello hello = new com.kuang.dao.Hello()
- 用 import 关键字引入，使用通配符 "*" , 导入io包下的所有类！
  
  import java.io.*;
  
  不建议这样使用，因为会全局扫描，影响速度！

JavaDoc

简介

javadoc可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。
也就是说，只要在编写程序时以一套特定的标签作注释，在程序编写完成后，通过 Javadoc就可以同时形成程序的开发文档了。
javadoc命令是用来生成自己API文档的，
使用方式：
使用命令行在目标文件所在目录输入javadoc +文件名.java。

以 /* 开始，以 / 结束。

@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况

命令行生成javadoc

进入文件Dos窗口，开始输入

-encoding UTF-8 -charset UTF-8 
//解决GBK乱码问题，在中间添加编码设置

利用IDEA生成javados

生成方法

posted @ 2021-02-14 17:10 feifan666 阅读(85) 评论(0) 收藏举报

刷新页面返回顶部