Java的学习笔记（02）基础
Java基础01：注释（书写注释是一个非常好的习惯） 单行注释 // //输出一个Hello world 多行注释 / / /*
多行注释多行所行*/ 文档注释 /** *java doc *java doc *java doc */ Java基础02：标识型和关键字 重要Java关键字列表 abstract:它利用计算机来完成抽象。它是与类和方法相关的非访问修饰符。
enum：它利用Java描述enum。
instanceof：它用于知道对象是否是预定义写入（类、子类或接口）的情况。
private：它是一个访问修饰符。任何被宣布为私有的东西都不能在其类外看到。
protected：如果您需要使组件能够在当前类之外查看，那么，只需对特定于您的类的子类进行查看，此时将宣布该组件。
public: 任何人从任何地方都可以到达的地方。
访问修改函数 static：它用于使成员（块、方法、变量或嵌套类）可以独立于任何其他成员使用，而无需参考特定情况。
strictfp：用于限制、浮点、浮点运算和计算，并在浮点变量中执行任务时保证每个阶段的结果相同。
synchronized：它用于在Java中获得适用于块和方法的同步。
transient：作为序列化的一部分使用的因子修饰符。在序列化的季节，如果我们不想对记录中的特定变量进行多余的估计，那么此时，我们使用transient关键字。
volatile：如果修饰符告诉编译器，由不稳定变量调整的变量通过程序的不同部分发生惊人的变化，则使用volatile。
Java关键字的类型 Enum Enum有效地表示编程语言中命名常量的集合。例如，一副扑克牌中的四套西服可能有四个名为Club、Diamond、Heart和Spade的统计员，其中一个位置有一个名为西服的已识别类别。不同的插图结合了正常识别的构图（如行星、一周中的几天、色调、方位等）。
当我们在编译时知道每一个可能的值时，JavaEnum就可以利用它。例如，这可能包括菜单上的决策、调整模式、召唤线横幅等。枚举写入中常量的排列永远保持不变并不重要。
Strictfp关键字 strictfp是Java中的一个关键字，它利用限制浮点值，并在执行滑行点变量中的任务时保证每个阶段的结果相同。
浮点计算从属于平台，即当类文档在各种平台（16/32/64位处理器）上运行时，不同的输出（浮点变量）完成。为了解决这类问题，根据IEEE754滑行点计数指南，以JDK1.2的形式提出了strictfp口号。
Strictfp的重要关注点： Strictfp修饰符按原样使用类、接口和技术。
Strictfp无法使用独特的策略。尽管如此，它还是利用了理论类/接口。
由于接口的技术当然是动态的，strictfp不能与接口内的任何方法一起使用。
标识符注意点 所有标识符都应该以字母，或者美元符号（$）或者下划线（_）开始 不能使用关键字作为变量名或者方法名 大小写非常敏感 不能以数字或者其他符号开头 可以使用中文名和拼音，但是不建议使用，不方便后期维护 Java基础03：数据型和关键字 基本数据类型 整数类型 byte 占1个字节（8位）
short 占2个字节（16位）
int 占4个字节（32位）
long 占8个字节（64位）
浮点数类型 float 4字节
double 8字节
字符类型 char 2字节
Boolean类型 1位：true false
public class demo02 {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
int num3 = 40;
long num4 = 100L; //Long 类型要在数字后加个L
//小数：浮点数
float num5 = 50.1F; //float 类型要在数字后加个F
//字符
char name = 'A';
char name3 = '张';
//字符串
String name2 = "张三";
//布尔类型
boolean flag = true;
}} Java基础04 数据类型扩展及面试题 最好完全避免使用浮点数进行比较！！！！！！！！ public class demo03 {
public static void main(String[] args) {
//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
//===================================================================
//浮点数拓展
//===================================================================
//float: 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全避免使用浮点数进行比较
float f = 0.1f;
double d = 0.1;
System.out.println(f==d); //判断是否相等 ：false
System.out.println(f);
System.out.println(d);
//字符
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int) c1); //强制转换，将a转化为数字
System.out.println(c2);
System.out.println((int) c2); //强制转换
// 所有字符本本质还是数字
//转义字符
// \t 制表符
// \n 换行
}} Java基础05 类型转换 运算中，不同类型的数据先转换为同一类型，然后进行运算。
从低到高位数据类型：byte 、short、char—>int—>long—>float—>double
public class demo05 {
public static void main(String[] args) {
int i = 128;
byte b = (byte) i; //强制转换
System.out.println(i);
System.out.println(b); //溢出
}} 强制转换 （类型）变量名 高—>低位
自动转化 低—>高位
注意点： 不能对布尔值进行转换 不能把对象类型转换为不想干的类型 在把高容量转换到低容量的时候，强制转换 转换的是时候可能存在内存溢出，或者精度问题！！！！！！！！ public class demo05 {
public static void main(String[] args) {
int i = 128;
byte b = (byte) i; //强制转换
System.out.println(i);
System.out.println(b); //溢出
System.out.println((int)23.7); //double类型 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
}} public class demo06 {
public static void main(String[] args) {
// 操作比较大的数字的时候，注意溢出的问题
// JDK7 新特性，数字之间可以用下划线分割
int money = 10_0000_0000L; //Long 类型要在数字后加个L
int years = 20;
int total = money*years; //-1474836480 ,计算的时候已经溢出了
long total2 =money*years; //默认是int类型，转换之前就已经存在问题了
long total3 = money*((long)years); //需要把years转换为long类型
System.out.println(total3);
}} Java基础06：变量、常量、作用域 类变量
实例变量
局部变量
public class demo08 {
// 实例变量，从属于对象;如果不进行初始化，这个类型的默认值 0 0.0
// 布尔值默认为false
//除了基本类型，其余的类型默认值为null
String name;
int age;
//类变量
static double salary = 2500;
//main方法
public static void main(String[] args) {
//局部变量；使用前必须声明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字= new demo08();
demo08 demo08 = new demo08();
System.out.println(demo08.age); // 0
System.out.println(demo08.name); // null
//类变量
System.out.println(salary);
}
//其他方法
public void add(){
}} 常量：设置之后不可再更改
常量修饰符: final
public class demo09 {
//常量修饰符: final
//修饰符，不存在先后顺序
static final double PI = 3.1415926;
public static void main(String[] args) {
System.out.println(PI);
}} 命名规范 见名知意 类成员变量： 首字母小写和驼峰原则：monthSalary 除了第一个单词意外后面单词首字母大写。 局部变量：首字母小写和驼峰原则 常量：大写字母和下划线 MAX_VALUE 类名：首字母大写和驼峰原则：Man，GoogMan 方法名：首字母大写和驼峰原则：run()，runRun() Java基础07运算符 算术运算符 +、-、*、/、%、++、--
赋值运算符 =
关系运算符 >、<、>=、<=、==、!=、instanceof
逻辑运算符 && || ! (与或非)
位运算符
条件运算符
拓展运算符
package operator;
public class demo1 {
public static void main(String[] args) {
//2元运算符号
//CTRL + D 复制当前行到下一行
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b); //可能产生小数，强转成double
}} package operator;
public class Demo02 {
public static void main(String[] args) {
long a = 12345678946545L;
int b = 123;
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 没有long类型，数据类型自动转为int类型,除非强转成double
}} package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符号
int a = 10;
int b = 20;
int c = 21;
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); //取余运算，模运算
}} Java基础08 自增自减运算符、初识math类 package operator;
public class Demo04 {
public static void main(String[] args) {
// ++ -- 自增、自减运算符
int a = 3;
int b = a++; // a = a +1 先赋值，再自增
System.out.println(a); // a = 4;
int c = ++a; // ++a a = a + 1; 先自增，再赋值
System.out.println(a);
System.out.println(a);
System.out.println(b);
System.out.println(b);
System.out.println(c);
System.out.println(c);
//幂运算 2^3 2*2*2 = 8
double pow = Math.pow(2,3);
System.out.println(pow);
}} Java基础09 逻辑运算符、位运算符 package operator;
public class Demo05 {
public static void main(String[] args) {
// 逻辑运算符 && || ！
boolean a = true;
boolean b = false;
System.out.println("a && b " +(a && b)); //两个都是真，结果为真
System.out.println("a || b " + (a || b)); //两个其中有一个是真，结果为真
System.out.println("!(a && b) " + !(a && b)); // 如果为真，则为假；如果为假，则为真。
//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4); // c<4 为false ，不运行c++ ,结果最后还是c = 5;
System.out.println(c);
System.out.println(d);
}} package operator;
public class Demo06 {
public static void main(String[] args) {
/*
* 位运算
* A = 0011 1100
* B = 0000 1101
*
* A&B = 0000 1100
* A|B = 0011 1101
* A^B = 0011 0001 //异或 相同取0，不同取1
* ~B = 1111 0010 //取反
*
* 2*8 = 16 2*2*2*2
* << *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<<3);
}} Java基础10 三元运算符及小结 package operator;
public class Domo07 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b; // a=a+b
a-=b; // a=a-b
System.out.println(a);
//字符串连接符 + ，string
System.out.println(""+a+b); // 1020 其中的“+”是字符串连接符
System.out.println(a+b+""); // 30 其中a与b之间的“+”是运算符，b后面的的“+”是字符串连接符
}} package operator;
public class Demo08 {
public static void main(String[] args) {
//三元运算符
// x ? y :z
//如果 x==true ,则结果为y,否者为z
int score = 80;
String Type2 = score < 60 ? "不及格":"及格";
System.out.println(Type2);
}} Java基础11 包机制 包的本质就是一个文件夹（）
一般利用公司域名倒置作为包名：com.luomoe.base
package com.baidu.base; //包
import com.baidu.base.demo03; //引入 import com.baidu.base.*; //引入 包内所有的类 Java基础12 JavaDoc生成文档 javadoc 命令是用来生成自己的API文档 /** 然后回车 /**
- @author zhangshan
- @version 1.0
- @since 1.8 * * */
cmd命令(生成web文档)
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
使用IEDA生成javadoc文档
（1）打开 idea,点击 Tools–> Generate JavaDoc,会弹出生成JavaDoc文档的配置页面。
（2）进行参数配置
（3）在输出目录里生成JavaDoc。