标签：jdk   内存   可读性   类修饰符   字符串   拓展   支持   api   原则   

Java基础

注释

Java中的注释有三种：

单行注释，多行注释，文档注释；

代码示例：

//单行注释
----------
/*
多行注释
多行注释
多行注释
*/
----------
/**
* JavaDoc文档注释
* @Description 描述
* @Author 作者
*/

标识符和关键字

标识符：

Java所有的组成部分都需要名字。类名、变量名以及方法名被称为标识符。

标识符注意点：

• 所有的标识符都应该以字母(A-Z或者a-z) ,美元符($) 、或者下划线( )开始。

• 首字符之后可以是字母(A-Z或者a-z) ,美元符($)、下划线( )或数字的任何字符组合。

• 标识符不能使用关键字作为变量名或方法名。

• 标识符大小写敏感。

关键字：

abstract：抽象类修饰符。class：类修饰符。
assert：boolean：布尔。break：byte：字节。case：catch：char：字符。const：continue：default：do：double：双精度。else：enum：枚举。extends：继承。final：修饰常量。finally：异常最后执行。float：单精度。for：goto：if：implements：实现接口。import：导入。instanceof：判断是否是这个类。int：整形。interface：接口修饰符。long：长整型。native：newpackage：private：私有修饰符。protected：public：公开修饰符。return：返回。stricttp：short：短整型。static：静态。super：父类调用。switch：synchronized：this：当前。throw：throwstransient：try：void：空。volatile：while：

数据类型

Java的数据类型分为两大类

基础类型(primitive type)

• 数值类型
  • 整数类型
    • byte占1个字节范围: -128-127
    • short占2个字节范围:-32768-32767
    • int占4个字节范围: -2147483648-2147483647
    • long占8个字节范围: -9223372036854775808-9223372036854775807
  • 浮点类型
    • float占4个字节
    • double占4个字节
  • 字符类型
    • char占2个字节
• boolean类型：
  • false占1个字节
  • true占1个字节

引用类型(reference type)

• 类
• 接口
• 数组

什么是字节
位(bit) :是计算机内部数据储存的最小单位，11001100是一 个八位二进制数。
字节(byte) :是计算机中数据处理的基本单位，习惯.上用大写B来表示。
1B (byte,字节) = 8bit (位)
字符:是指计算机中使用的字母、数字、字和符号
1bit表示1位、1Byte表示一个字节1B=8b。
1024B=1KB
1024KB= 1M
1024M=1G

数据类型扩展

• 整数拓展

  二进制0b开头，十进制，八进制0开头，十六进制0x开头

  //整数拓展：   进制    二进制0b开头   十进制   八进制0开头   十六进制0x开头
          int i = 10;     //
          int i2 = 010;   //    八进制0开头
          int i3 = 0x10;  //    十六进制0x开头
          System.out.println(i);//10
          System.out.println(i2);//8
          System.out.println(i3);//16

• 浮点数扩展

  //浮点数扩展
          //BigDecimal   数学工具类
          //最好完全使用浮点数进行比较
          float f = 0.1f; //0.1
          double d = 1.0/10;  //0.1
          System.out.println(f==d);//false
          float f1 = 23232323232323f;
          float f2 = f1 + 1;
          System.out.println(f1==f2);//true

• 字符扩展

  字符可以强转为数值类型，编码表

  //字符扩展
          char c1 = 'a';
          char c2 =  '中';
          System.out.println(c1);//a
          System.out.println((int)c1);//97
          System.out.println(c2);//中
          System.out.println((int)c2);//20013
        //所有的字符本质还是数字
          //编码   Unicode  编码表(97=a, 65=A)
          char c3 = '\u0061';
          System.out.println(c3);//a

• 转义字符

  //转义字符
          //\t  制表符
          //\n  换行
          //...还有其他
          System.out.println("hello\tword");//\t  制表符  Tab
          System.out.println("hello\nword");//\n  换行

• 字符串比较

  //== 比较的是地址       
          String sa = new String("hello,world");
          String sb = new String("hello,world");
          System.out.println(sa==sb);//false  值一样内存地址不一样
          String sc = "hello,world";
          String sd = "hello,world";
          System.out.println(sc==sd);//true  同一个地址，不同引用

• 布尔值扩展

  //布尔值扩展
          boolean flag = true;
          if (flag==true){}
          if (flag){}//flag默认为true
          //代码精简

类型转换

类型转换
由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

低--------------------------------------------------------------高

byte, short,char-> int -> long- -> float -> double
运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
自动类型转换

int i = 128;
byte b = (byte)i; //内存溢出  //低--高
double d = i    //高--低
//强制转换(类型)变量名 高--低
//自动转换低--高
System.out.println(i);//128
System.out.println(b);//-128
System.out.println(d);//128.0

• 注意点:
  1.不能对布尔值进行转换。
  2.不能把对象类型转换为不相干的类型。
  3.在把高容量转换到低容量的时候，强制转换。
  4.转换的时候可能存在内存溢出，或者精度问题!

System.out.println((int)23.7); //23
System.out.println((int)-45.89f); //-45

• 数字与字符转换

char c ='a';
int d = c+1;
System. out.println(d);//98
System. out . println((char)d);//b

• 操作比较大的数的时候，注意溢出问题

//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years; //计算的时候溢出了   
        System.out.println(total);//-1474836480
        long total2 = money*years; //默认是int,转换之前已经存在问题了?
        System.out.println(total2);//-1474836480
        long total3 = money*((long)years); //先把一个 数转换为ong
        System. out. println(total3) ;//20000000000

变量,常量,作用域

变量

变量是什么: 就是可以变化的量!
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

int a;
//int a,b,c;
//int a=1,b=2,c=3;  //程序的可读性用int a;
String name = "zhangsan";
char c = '字'；
double d = 3.14; 

作用域

• 类变量

public class Student{       //类
    static int i = 0;       //类变量
        public void method( ){  //方法
    }
}

• 实例变量

public class Student{           //类
        //实例变量:从属于对象;如果不自行初始化，这个类型的默认值。
        //单精度0.0，双精度0.00
        //布尔值:默认是false
        //除了基本类型，其余的默认值都是null;
        String str="hello world";   //实例变量（全局变量）
        Student s = new Student();  //实例变量（全局变量）
        public void method( ){      //方法
    }
}

• 局部变量

public class Student{           //类
    public void method( ){      //方法
    //局部变量；必须声明和初始化值
        Student s1 = new Student(); //局部变量
        int i = 0;                  //局部变量
    }
}

• 默认值

//属性:变量
//实例变量:从属于对象;如果不自行初始化，这个类型的默认值。
//布尔值:默认是false
//除了基本类型，其余的默认值都是null;|
String name;
int age;

常量

常量(Constant): 初始化(initialize)后不能再改变值!不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

//final 常量名 = 值;
final double PI = 3.14;
final String PI = "张三";//常量名一般使用大写字符。

变量的命名规范

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

运算符

Java语言支持如下运算符:

算术运算符:(+, -,*, /, %,++, --)

[加（+）、减（-）、乘（*）、除（/）、取余（%）、自增（++）、自减（--）]
++是加1，--是减1

public class Test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        System.out.println(a+b);//5     3+2=5
        System.out.println(a-b);//1     3-2=1
        System.out.println(a*b);//6     3*2=6
        System.out.println((double) a/b);//1.5    3/2=1.5
        System.out.println(a%b);//1    3/2=1 取余1
        a++;
        System.out.println(a);//4
        b--;
        System.out.println(b);//1
    }
}

自增自减：a++,++a的区别

public class Test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        //++自增，--自减   一元运算符
        //a++ a = a + 1;
        int c = a++ ; //执行完这行代码后， 先给c赋值,再自增，所以a赋给c=3，a+1在这代码后a输出为4.
        System.out.println(c);//3
        System.out.println(a);//4
        int d = ++a; //执行完这行代码前，先自增，再给d赋值。
        System.out.println(d);
    }
}

字符串连接符和运算符加号

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //字符串连接符 +  String
        //如果前面出现拼接字符串后面也会拼接不会计算
        System.out.println(""+a+b);//1020
        //如果后面出现拼接字符串前面会计算再拼接
        System.out.println(a+b+"");//30
    }
}

一般会使用一些工具类来运算：如Math类。

public class Test {
    public static void main(String[] args) {
        //幂运算 2^3  2*2*2=8,很多运算，一般会使用一些工具类来操作
        double pow = Math.pow(2, 3);//使用Math类
        System.out.println(pow);//8.0
    }
}

赋值运算符:(=)

[赋值（=）]

pubilc class Test{
    public static void main(String[] args) {
        int a = 3;
        int b = a;
        System.out.println(a);//3
        System.out.println(b);//3
    }
}

关系运算符:(>, <, >=, <=, ==, != instanceof)

[大于（>），小于（<），大于等于（>=），小于等于（<=），等于（==），不等于（!=）]
instanceof面向对象阶段学习。

public class Test {
    public static void main(String[] args) {
        //关系运算符返回布尔值,结果要么正确要么错误。
        int a = 10;
        int b = 20;
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a>=b);//false
        System.out.println(a<=b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
    }
}

逻辑运算符:(&&, ||，!)

[&&（与and）, ||（ 或or），!（非）]

public class Test {
    public static void main(String[] args) {
        //与(and)   或(or)   非(取反)
        boolean a = true;
        boolean b = false;
        //逻辑与运算:
        System.out.println("a&&b:"+(b&&a)); //两个变量都为真，结果才为true
        System.out.println("a||b:"+(a||b)); //两个变量有一个为真， 则结果才为true
        System.out.println("!(a&&b):"+!(a&&b)); //如果是真，则变为假，如果是假则变为真
    }
}

&&的短路运算理解

public class Test {
    public static void main(String[] args) {
        //短路运算
        int c = 5;
        boolean d = (c==4)&&(c++<4);//当第一个不等于true的时候直接结束运算
        System.out.println(d);//false
        System.out.println(c);//5
        boolean e = (c>4)&&(c++>4);//当第一个等于true的时候则继续执行第二个知道不满足
        System.out.println(e);//true
        System.out.println(c);//6
    }
}

位运算符:(&,|,^,~,>>,<<,>>>)

位运算效率极高因为直接和底层打交道。

按位与运算符：&（如果两个都为1则为1，否则为0）
按位或运算符：|（如果两个都为0则为0，否则为1）
异或运算符：^（如果两个相同为0，不相同为1）
取反运算符：~（如果是0则为1，如果是1则为0）

/*示例：
两个二进制的数A B
A = 0011 1100
B = 0000 1101
A&B = 0000 1100     如果两个都为1则为1，否则为0
A/B = 0011 1101     如果两个都为0则为0，否则为1
A^B = 0011 0001     如果两个相同为0，不相同为1
~B = 1111 0010      如果B的0则为1，如果是1则为0
*/

右移运算符：<<（乘于2）
左移运算符：>>（除于2）

public class Test {
    public static void main(String[] args) {
        /*面试题 2*8 = 16怎么运算更快,使用位运算符
        2*2*2*2
        0000 0000       0
        0000 0001       1
        0000 0010       2
        0000 0011       3
        0000 0100       4
        0000 1000       8
        0001 0000       16*/
        System.out.println(2<<1);//4
        System.out.println(2<<2);//8
        System.out.println(2<<3);//16
    }
}

条件运算符: (? :)

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

public class Test {
    public static void main(String[] args) {
        //判断成绩是否及格
        int score = 88;
        String zhangsan = score < 60 ?"不及格":"及格";
        System.out.println(zhangsan);//及格
    }
}

扩展赋值运算符:(+=, -=, *=, /=)

public class Test {
    public static void main(String[] args) {
        int a = 10;
        a+=2; //a = a+2
        System.out.println(a);//12,a = 10+2
        a-=2; //a = a-2
        System.out.println(a);//10,a = 12-2
        a*=2; //a = a*2
        System.out.println(a);//20,a = 10*2
        a/=2; //a = a/2
        System.out.println(a);//10,a = 20*2
    }
}

包机制

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包语句的语法格式为：

//定义包：
package com.ys;

一般利用公司域名倒置作为包名。

例：com.baidu.www;

为了能够使用某一个包的成员， 我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能。

//导入ys包下的Test类
import com.ys.Test;
//导ys包下的所有类
import com.ys.*;

JavaDoc文档

javadoc命令是用来生成自己API文档的。
参数信息
@author作者名
@version版本号
@since指明需要最早使用的jdk版本
@param参数名
@return返回值情况
@throws异常抛出情况

/**
 * @Author ys      作者名
 * @Version 1.0    版本号
 * @Since 1.8      指明需要最早使用的jdk版本
 */
public class Doc {
    /**
     *
     * @param name      参数名
     * @return          返回值情况
     * @throws Exception     异常抛出情况
     */
    public String test(String name)throws Exception{
        return name;
    }
}

Dos命令窗口下使用命令:

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

idea也可以生成JavaDoc文档

Java基础

标签：jdk   内存   可读性   类修饰符   字符串   拓展   支持   api   原则   

原文地址：https://www.cnblogs.com/yu-si/p/12496838.html