标签：比较   months   instance   int   除了   下划线   换行   money   分析   

Java基础

注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构的一旦复杂起来，我们就需要用到注释了。

注释并不会被执行，是给我们写代码的人看的

书写注释是一个非常好的习惯

平时写代码一定要注意规范

Java中的注释

• 单行注释：可以注释一行文字

  // 这是单行注释
  

• 多行注释：可以注释多行文字

  /*
  这是多行注释
  这是多行注释
    */
  

• 文档注释

  /**
   * 这是文档注释
   */
  

标识符

每个人都有名字，每件事物都有名字，程序也不例外

关键字

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

标识符注意点

• 所有的标识都应该是以字母（A-Z 或者 a-z），美元符（$）、或者下划线（_）开始

• 首字符之后可以是字母（A-Z 或者 a-z），美元符（$）、或者下划线（_）或数字的任何字符组合

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

• 标识符是大小写敏感的

• 合法标识符举例：age、$teacher、_value、Hello、__1_value

• 非法标识符举例：123adc、-salary、#abc

• 可以使用中文命名，但是一般不建以这样去使用，也不建议使用拼音，很Low

  public static void main(String[] args) {
      String 英雄联盟 = "最强王者";
      System.out.println(英雄联盟);
  }
  

数据类型

强类型语言：Java、C、C++

? 要求变量的使用要严格符合规定，所有的变量必须先定义后才能使用

? 优点：安全性高

? 缺点：速度慢

弱类型语言：JavaScript、VBScript、PHP

? 优点：简单、速度快

? 缺点：容易出错

Java的数据类型分类

• 基本类型（primitive Type）

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

  //八大基本数据类型
  
  //整数
  int num1 = 100000; //最常用
  byte num2 = 127; // -127 - 128
  short num3 = 128;
  long num4 = 1000000L; // Long类型要在数字后面加L
  
  //小数：浮点数
  float num5 = 70.2f; // Float类型要在数字后面加F
  double num6 = 3.1415926535897932238462643;
  
  // 字符类型
  char name = ‘中‘; //字符，一个字
  // 字符串，String不是关键字，是一个类
  //String name2 = "姓名";
  
  //布尔值:是非
  boolean flag = true;
  boolean flag2 = false;
  

• 引用类型（Reference Type）

  类，接口，数组

  String是一个类，也属于引用数据类型

字节

• 位（bit）：是计算机 内部数据 存储的最小单元，1001100是一个八位二进制数

• 字节（byte）：是计算机中 数据处理 的基本单元，习惯上用大写 B 来表示

• 1B（byte，字节） = 8bit（位）

• 字符：是指计算机中使用的字母、数字、字符符号

• 1bit表示1位

• 1Byte表示一个字节 1B = 8b

• 1024B = 1kb

• 1024KB = 1M

• 1024M = 1G

• 1024G = 1TB

• 1024TB = 1PB

数据类型扩展及面试题讲解

整数拓展

//进制      二进制用"0b"表示     十进制     八进制"0"     十六进制"0x"
int i = 2;
int i2 = 010; // 八进制的10
int i3 = 0x10; // 十六进制的10  0~9 A~F

System.out.println(i); // 10
System.out.println(i2); // 8
System.out.println(i3); // 16

浮点数拓展

? 银行业务怎么表示钱呢？ BigDecimal 数学工具类

float f = 0.1f;
double d = 1.0 / 10;
System.out.println(f); // 0.1
System.out.println(d); // 0.1
System.out.println(f == d); //false

float d1 = 232312352133f;
float d2 = d1 + 1;
System.out.println(d1 == d2); //true

float 的特点：有限 离散 舍入误差 大约数 接近但不等于

结论 ：最好完全避免使用浮点数进行比较

字符拓展

> 通过强制类型转换，可以将char字符转换为Unicode编码格式

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

? 所有的字符本质还是数字

? Unicode编码：2字节 长度：0~65536；

? Unicode表 a = 97; A = 65

? Excel表格 最长是2的16次方 = 65536

// Unicode编码一般采用 U0000 UFFFF表示
char c3 = ‘\u0061‘;
System.out.println(c3); // a

? 转义字符

// \t 制表符
// \n 换行符
// ……
System.out.println("Hello\tWorld");
System.out.println("Hello\nWorld");

String拓展

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){} // 老手
//Less is More！ 代码要精简易读

类型转换

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

?

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

强制类型转换

• 条件是转换的数据类型必须是兼容的
• 格式：(type)value type是要强制类型转换后的数据类型

强制类型转换也叫“向下类型转型”，它是高级转为低级。

例如int num = 123; byte b = (byte)num; //强制类型转换为byte

自动类型转换

? 必须满足转换前的数据类型的位数要低于转换后的数据类型

自动类型转换也叫“向上类型转换”，它是低级转为高级。

例如 char a = ‘a‘; int num = a; 这时就是向上类型转型，由char类型转为int类型 num = 97;

隐含强制类型转换

• 整数的默认类型是 int。
• 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或 f

【注意】

1. 不能对Boolean进行转换
2. 不能把对象类型转化为不相干的类型
3. 在把大容量转换为低容量时，强制类型转换
4. 转换的时候，可能存在内存溢出问题、精度问题

// 示例
System.out.println((int) 12.3); // 12
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; // 1000000000

常见问题

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

int money = 10_0000_0000;
int year = 20;
int total = money * year; // 理论上应该是20亿，结果是-1474836480，因为计算的时候内存
long total2 = money * year; // money和year都是int，结果默认是int，在转换为long之前就出错了

解决方案

long total3 = ((long)money) * year; // 先将一个数转化为long，结果就是long，解决了溢出问题
System.out.println(total3);

【注意】

> 注意，在定义long时，后面需要加 L 或者 l ，建议使用L，防止 l 看成 1;

变量

变量的概念

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

type varName = [=value][{,varName[=value]}];
// 数据类型  变量名 = 值；  可以用逗号隔开来声明多个相同数据类型的变量。
// 基本类型
int a = 1;
int b = 2, c = 3; // 不建议,程序可读性问题
char x = ‘X‘;
double pai = 3.14;
// 引用类型
String name = "hello";

注意事项：

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

变量的作用域

变量是有作用范围（Scope）的，也即作用域。一旦超出变量的作用域，就无法再使用这个变量。在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区便是这个变量的作用域。

• 类变量

  在类体内定义的变量称为类变量，它的作用域是整个类，也就是说在这个类中都可以访问到定义的这个类变量

  public class Demo04 {
      // 类变量 static
      static double salary = 2500;
  
      public static void main(String[] args) {
          // 类变量 static
          System.out.println(salary);
      }
  }
  

• 实例变量

  实例变量：从属于对象;如果不初始化，就变成了这个类型的默认值

  所有的数值类型，基本上都是 0 或者 0.0

  布尔值的默认值：false

  除了基本类型，其余的默认值都是null

  public class Demo08 {
  	// 实例变量：从属于对象;如果不初始化，就变成了这个类型的默认值
      // 所有的数值类型，基本上都是 0 或者 0.0
      // 布尔值默认值：false
      // 除了基本类型，其余的默认值都是null
      String name;
      int age;
  
      public static void main(String[] args) {
          // 变量类型 变量名 = new 变量类型();
          Demo08 demo08 = new Demo08();
          System.out.println(demo08.age); // 0 
          System.out.println(demo08.name); // null
      }
  }
  

• 局部变量

  在一个方法或方法内代码块中定义的变量称为局部变量，局部变量在方法或代码块被执行时创建，在方法或代码块结束时被销毁。局部变量在进行取值前必须被初始化，否则会编译错误

  Java存在块级作用域，在程序中任意大括号包装的代码中定义的变量，它的生命仅仅存在于程序运行该代码块时

  public class Demo04 {
      public static void main(String[] args) {
          // 局部变量；在方法内部定义的变量，就是局部变量
          // 必须声明和初始化值
          int i = 10;
          System.out.println(i);
      }
  }
  

变量的命名规范

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

常量

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

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

常量名一般使用全大写字符

final 常量名 = 值;
final double PI = 3.14;
// 修饰符不存在先后顺序
final static double PI = 3.14;

在开发中合理使用常量可以提高代码的可读性

public class Demo09 {
    // 修饰符不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

? Java语言支持如下运算符：

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>，=，
• 逻辑运算符：&&，||，!
• 位运算符：&，|，^，~，>>，>>（了解！！！）
• 条件运算符：？:
• 拓展赋值运算符：+=，-=，*=，/=

算数运算符

// 两数及多数操作也叫做 ：二元运算符
int a = 10;
int b = 20;
int c = 25;
int d = 30;
System.out.println(a + b); // 两数相加 结果为：30 
System.out.println(a - b); // 两数相减 结果为：-10
System.out.println(a * b); // 两数相乘 结果为：200
System.out.println(a / b); // b取整a 结果为：0
System.out.println(a % b); // b取余(模运算)a 结果为：10
System.out.println(a / (double)b); // a除以b 结果为： 0.5 

不同数据类型混合运算

long a = 20522285412L;
int b = 12123;
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
// 不同运算符进行运算时，结果自动提升为最大的数据类型
// short + byte = int

关系运算符

// 关系运算符返回的结果：正确、错误 使用布尔值表示
// 之后会大量和if结合使用
int a = 10;
int b = 20;
System.out.println(a > b); // false
System.out.println(a 

自增自减运算符

? ++在前，先自增再赋值；++在后，先赋值再自增

// ++ 自增；-- 自减 一元运算符
int a = 3;
int b = a++; // 执行完这行代码后，先给b赋值，再自增
// a++ 相当于 a = a + 1;
System.out.println(a);  // 4
int c = ++a; // 执行完这行代码前，先自增，再给b赋值

System.out.println(a); // 5
System.out.println(b); // 3
System.out.println(c); // 5

? 拓展：Math，数学工具类

// 幂运算 2^3 = 2 * 2 * 2 = 8
// 很多运算，我们会使用一些工具类来操作
double pow = Math.pow(2, 3);
System.out.println(pow); // 8

逻辑运算符

// 与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b：" + (a && b)); // 逻辑与运算：两个变量都为true，结果才为true
System.out.println("a || b：" + (a || b)); // 逻辑或运算：两个变量有一个为true，结果就为true
System.out.println("!(a && b)：" + (!(a && b))); // 如果是true，结果就为false，反之亦然
//短路运算
int c = 5;
boolean d = (c 

位运算符

A = 0011 1100
B = 0000 1101

A&B 0000 1100 与运算符：按位进行比较，都为1才是1，否则为0
A|B 0011 1101 或运算符：都是0就为0，有一个1，就都为1
A^B 0011 0001 异或运算符：相同就为0，不相同就为1
~B  1111 0010 非运算符 如果为1就变为0，如果为0就变为1

面试题：如何运算 2 * 8 最快

// >右移   / 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

拓展赋值运算符

int a = 10;
int b = 20;

a += b; // a = a + b
a -= b; // a = a - b

// 字符串连接符 + 加法两侧只要出现了String类型，其他类型都变为String再进行拼接
System.out.println(a + b);
System.out.println("" + a + b);

面试题

System.out.println("" + a + b); // 1020 先转为String再拼接
System.out.println(a + b + ""); // 30 先计算再转为String拼接

三元运算符

// x ? y : z
//如果x为true，结果为y，否则结果为z
int score = 80;
String type = score 

运算优先级

单目乘除为关系，逻辑三目后赋值

单目运算符：一次作用一个变量的运算符，又叫一元运算符
单目：单目运算符+ –(正负数) ，++ –，！（逻辑非），~（按位取反）
乘除：算数运算符：* / % + - （* / %优先级肯定是大于+-的）
为：位运算符：~（按位取反）>(右移)，^（也可以位运算，二进制异或）
关系：关系运算符：> = 逻辑：逻辑运算符（除！）&& || & | ^
三目：条件运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：= += -= *= /= %= |= &= ^=

一般使用括号进行优先级分别

包机制

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

包的本质就是文件夹

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

www.baidu.com 包名为 com.baidu.com

包的语法格式为：package 包名

为了能够使用某一个包的成员，我们需要在Java程序中明确的导入该包，使用“improt”语句

package com.jh.operstor;

import java.util.Date;

public class Demo09 {
    public static void main(String[] args) {
        Date date = new Date();
    }
}

导入一个包里的所有类

import com.jh.base.*;

注意：package必须为程序的第一行；不要导入和当前类名一样的类

JavaDoc

JavaDoc命令是用来生成自己的API文档的

参数信息：

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

使用cmd生成javaDoc文档：

javadoc -encoding utf-8 -charset utf-8 文件名.java
# -encoding utf-8 -charset utf-8 防止出现中文乱码

使用IDEA生成JavaDoc文档：

Tools 》Generate JavaDoc 》选择需要生成的模块，输出路径，语言，点击确定即可

学习地址：https://www.bilibili.com/video/BV12J41137hu

Java基础

标签：比较   months   instance   int   除了   下划线   换行   money   分析   

原文地址：https://www.cnblogs.com/paidaxing0623/p/14123681.html