Java基础语法

标签：cat   ==   sys   三元运算符   速度慢   prim   保留字   存储   运行   

Java基础语法

1. 注释 ，标识符，关键组
2. 数据类型
3. 类型转换
4. 变量，常量
5. 运算符
6. 包机制，JavaDoc

java注释有三种

• 单行注释
• 多行注释
• 文档注释

书写注释事非常好的习惯 写代码要规范

有趣的代码注释

/***
 *                    .::::.
 *                  .::::::::.
 *                 :::::::::::  YOU~~
 *             ..:::::::::::‘
 *           ‘::::::::::::‘
 *             .::::::::::
 *        ‘::::::::::::::..
 *             ..::::::::::::.
 *           ``::::::::::::::::
 *            ::::``:::::::::‘        .:::.
 *           ::::‘   ‘:::::‘       .::::::::.
 *         .::::‘      ::::     .:::::::‘::::.
 *        .:::‘       :::::  .:::::::::‘ ‘:::::.
 *       .::‘        :::::.:::::::::‘      ‘:::::.
 *      .::‘         ::::::::::::::‘         ``::::.
 *  ...:::           ::::::::::::‘              ``::.
 * ```` ‘:.          ‘:::::::::‘                  ::::..
 *                    ‘.:::::‘                    ‘:‘````..
 */

标识符和关键字

   java中包含50个关键，所有关键字都是小写的
    关键字列表：
     abstract抽象的            assert 
     boolean                   break 
     byte                      case
     catch                     char
     const(保留字)             continue
    default                    do
     double                    else
     enum                      extends
     final                     finally
     float                     for
     if                        goto(保留字)
     implements                import
     int                       interface
     long                      native
     new                       package
     private                   protected
     public                    return 
     short                     static 
     strictfp                  super
     switch                    synchronized
     this                      throw
     throws                    transient
     try                       void 
     volatile                  while

• 所以的标识符 都应该以字母 （A--Z或者a--z, $ ,_）开始
• 标识符大小写敏感

数据类型

Java 强类型语言 变量的使用 严格符合规定 变量必须先定义再使用（安全，速度慢）

Java数据分为两大类型

? 基本类型（primitive type)

• 整数类型

  • int num1 = 10;
    byte num2 = 20;
    short num3 = 32;
    long num4 = 30L;
    

• 浮点类型

  • 有限 离散 接近 但 不等于 最好不要用浮点数 比较

  float = num5 = 50.1F;
  double = num6 = 3.1415926;
  

• 字符类型

  • 所有的字符 本质还是 数字 Unicode 2字节 65535 个字符 **97 = a | ** 65 = A

    char name = ‘国‘;
    

• 布尔类型

  • boolean flag = true;  
    

? 引用类型 (reference type)

• 类
• 接口
• 数组

面试题

String sa = new String(original:"Hello world");
String sb = new String(original:"Hello world");
System.out.println(sa == sb);
输出 为 Fales
String sa = "Hello world";
String sb = "Hello world";
System.out.println(sa == sb);
输出为 True

原因是： 第一个是分配到堆内存中，第二个是常量池中

数据类型转换

低 -------------------------------------------------> 高

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

int i = 128;
byte b = (byte)i;

System.out.println(b);

输出为 -127
//内存溢出 ， byte（-127  127） 

运算中不同类型的数据先转化为 同一类型 ， 再进行运算

• 强制类型转换
  • （类型）变量名 高--->低
• 自动类型转换
  • 低--->高 不需要 任何操作 直接 int = double

注意：

• 不能对 布尔类型 进行转换
• 不能把 对象类型 转换成 不相干 的类型
• 大容量转换成低容量的时候 **强制转行 ** 可能出现 内存溢出 精度问题

//Jdk 7 新特性  数字可以用_分割
int money = 10_0000_0000;
int years = 20;
int total = money*years; // -1474836480,计算的时候溢出了
long tatal2 = maney*years; //默认是 int， 转换之前已经存在
所以输出还是 -1474836480
    
long total3 = money*((long)years);//先把一个数转换成Long
输出 正常

变量

variable

? 一个放东西 的 空间 ---狂神说

? 位置是 确定的 空间的东西 不确定

• Java 是一种强类型语言，每个变量都必须声明七类型

• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型 和 作用域

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

• 注意：

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

作用域

• 类变量
• 实例变量
• 局部变量

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

public class Demo{
    
    // 类变量 static   从属于类，和类一起出现，一起消失。
    static double salary = 2500;
    
    //属性：变量
    
    //实例变量：从属于对象；如果不进行初始化，复制这个类型的默认值
    String name;  //String 默认值 为 null
    int age;      //int 值默认值 为 0   布尔值 默认 为 False 除了 基本类型 默认值都为 null
    
    //main方法
    public static void main(String[] args){
        //局部变量；必须声明和初始化值
        int i = 10;
        
        //变量类型(demo08自定义类)  变量名字 = new Demo08();  demo08 里面的作用域 为 demo08()
        demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);
        
        // 类变量 static  
        System.out.println(salary);
    }
    
    //其他方法
    public void add(){}
}

常量

• 常量（constant）: 初始化（initialize） 后不能再改变值！不会变动的值。

• 所谓常量可以理解为一种特殊的变量，它被设定后，再程序中运行不允许被更改 (游戏的 长 宽 高 等)

  fianl 常量名 = 值
  fianl double PI = 3.14;
  

• 常量名 一般用 大写字符

public class Demo{
    
    //修饰符，不存在先后顺序
    final static double RIDOS = 5;
   	static final double PI = 3.14;
    
    public static void main(String[] args){
        System.out.println(PI)
        System.out.println(PIDOS)
    }
}

变量的命名规则

• 所有变量名，方法，类名：见名知意
• 类成员变量：首字母小写 和 驼峰 原则：monthSalary
• 局部变量：首字母小写 和 驼峰 原则
• 常量： 大写 字母和 下划线 MAX_VALUE
• 类名：首字母大写 和 驼峰 原则 Man, GoodMan
• 方法名：首字母小写 和 驼峰 原则 run(), runOne()

运算符

Oeperator

• 算术运算符 ： +， -， * ，/ %（模运算（取余） ，++， --
• 赋值运算符 ： =
• 关系运算符： < ，> ，<=， >= ，== ， !=， instanceof
• 逻辑运算符： &&， ||， ！
• 位运算符：&， | ，^, ~ , >>, <<, >>>
• 条件运算符 ：？：
• 扩展赋值运算符： += ， -=， *=， /=

//ctrl + D 复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 30;

System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(c%a);

30
-10
200
0
5
    
System.out.println(a/(double)b);
0.5

二元运算符

int a = 3;
b = a++  //先赋值 再自增   
c = ++a  //先自增 再赋值

幂运算

double pow = Math.pow(3,2);
System.out.println(pow);

面试题

• 有 long类型 操作后 就是 long类型
• 无long有double类型 操作后 就是 double类型
• 无long double有 int 操作和 为 int类型
• 啥都没有 操作后 是 int 类型

long a = 1234579854;
int b = 123;
short = 54;
byte = 8;

System.out.println(a+b+c+d);  // long类型
System.out.println(b+c+d);    // int类型
System.out.println(c+d);	  // int类型  cast： 转换
										

关系运算

返回值 为 布尔值

幂运算

double pow = Math.pow(3,2);
System.out.println(pow);

位运算

A = 0000 1100
B = 0011 1101

A&B = 0000 1100
A|b = 0011 1101
A^B = 0011 0001  #相同位置的数相同 为0
~B  = 1111 0010

//面试题
2 * 8 怎么最快？2*8 = 2*2*2*2
左移 右移
<<   >>
System.out.println(2<<3);
结果输出
    16

解：
    0000 0000	0
    0000 0001	1
    0000 0010	2
    0000 0011	3
    0000 0100	4
    ---- ----   -
    0000 1000	8
    ---- ----   -
    ---- ----   -
    0001 0000   16
   
    <<  = *2
    >>  = /2

字符串连接符

a = 10;
b = 20;
System.out.println(""+a+b);
System.out.println(a+b+"");
//输出结果
1020
30

三元运算符

x ? y : z
//如果x==true, 则结果为y，否则为z

包机制

• 区别于命名空间
• 一般利用公司域名倒置作为包名 com.baidu.www
• package 必须放到最上面
• 定义包 package 导入包 import import com.kuang.* （ *通配符） 导入这个 kuang包的所有类

JavaDoc

• JavaDoc是用来生成帮助文档的（自己的API文档）
• 参数设置
  • @author 作者名字
  • @version版本号
  • @since指明需要最早使用的JDK版本
  • @param参数名
  • @return返回值异常
  • @throws异常抛出情况

JavaDoc是用来生产自己的API文档。

Java基础语法

标签：cat   ==   sys   三元运算符   速度慢   prim   保留字   存储   运行   

原文地址：https://www.cnblogs.com/AronJudge/p/14147179.html