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。

原创文章：https://www.qqhhs.com，作者：起航®，如若转载，请注明出处：https://www.qqhhs.com/27.html

Java的学习笔记（02）基础

待问君好，我是起航，一个有着无限可能的流浪疯子。

起航®

发表回复

Java的学习笔记（02）基础

待问君好，我是起航 ，一个有着无限可能的流浪疯子。

起航®

相关推荐

发表回复

待问君好，我是起航，一个有着无限可能的流浪疯子。