Java的学习笔记(02)基础

简介: 访问修改函数static:它用于使成员(块、方法、变量或嵌套类)可以独立于任何其他成员使用,而无需参考特定情况。strictfp:用于限制、浮点、浮点运算和计算,并在浮点变量中执行任务时保证每个阶段的结果相同。synchronized:它用于在Java中获得适用于块和方法的同步。transient:作为序列化的一部分使用的因子修饰符。在序列化的季节,如果我们不想对记录中的特定变量进行多余的估计,那么此时,我们使用transient关键字。volatile:如果修饰符告诉编译器,由不稳定变量调整的变量通过程序的不同部分发生惊人的变化,则使用volatile。Java关键字的

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不能与接口内的任何方法一起使用。

标识符注意点

  1. 所有标识符都应该以字母,或者美元符号($)或者下划线(_)开始
  2. 不能使用关键字作为变量名或者方法名
  3. 大小写非常敏感
  4. 不能以数字或者其他符号开头
  5. 可以使用中文名和拼音,但是不建议使用,不方便后期维护

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); //溢出
    }
}

强制转换 (类型)变量名 高—>低位

自动转化 低—>高位

注意点:

  1. 不能对布尔值进行转换
  2. 不能把对象类型转换为不想干的类型
  3. 在把高容量转换到低容量的时候,强制转换
  4. 转换的是时候可能存在内存溢出,或者精度问题!!!!!!!!
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);
    }
}

命名规范

  1. 见名知意
  2. 类成员变量: 首字母小写和驼峰原则:monthSalary 除了第一个单词意外后面单词首字母大写。
  3. 局部变量:首字母小写和驼峰原则
  4. 常量:大写字母和下划线 MAX_VALUE
  5. 类名:首字母大写和驼峰原则:Man,GoogMan
  6. 方法名:首字母大写和驼峰原则: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生成文档

  1. javadoc 命令是用来生成自己的API文档 /** 然后回车
/**
 * @author zhangshan
 * @version 1.0
 * @since 1.8
 *
 *
 */

cmd命令(生成web文档)

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

  1. 使用IEDA生成javadoc文档
    (1)打开 idea,点击 Tools–> Generate JavaDoc,会弹出生成JavaDoc文档的配置页面。
    (2)进行参数配置
    (3)在输出目录里生成JavaDoc。
相关文章
|
1月前
|
前端开发 Java 数据安全/隐私保护
Java学习—GUI编程学习笔记
Java学习—GUI编程学习笔记
|
1月前
|
存储 Java
最新Java基础系列课程--Day10-IO流文件处理(一)
最新Java基础系列课程--Day10-IO流文件处理
|
2月前
|
存储 缓存 Java
最新Java基础系列课程--Day10-IO流文件处理
最新Java基础系列课程--Day10-IO流文件处理
|
4月前
|
Java 编译器
【Java学习笔记】 对象和类
【Java学习笔记】 对象和类
|
2月前
|
存储 缓存 安全
《java核心技术36讲》学习笔记-------杨晓峰(极客时间)
《java核心技术36讲》学习笔记-------杨晓峰(极客时间)
33 0
|
22天前
|
缓存 分布式计算 Java
Java基础深化和提高-------IO流
Java基础深化和提高-------IO流
98 0
|
1月前
|
缓存 Java Apache
最新Java基础系列课程--Day10-IO流文件处理(三)
最新Java基础系列课程--Day10-IO流文件处理
|
1月前
|
Java
最新Java基础系列课程--Day10-IO流文件处理(二)
最新Java基础系列课程--Day10-IO流文件处理
|
2月前
|
数据采集 缓存 分布式计算
java并发编程实践——王宝令(极客时间)学习笔记
java并发编程实践——王宝令(极客时间)学习笔记
24 0
|
2月前
|
Java 数据库连接 数据库
Java大数据开发工程师__Spring学习笔记(待更新)
Java大数据开发工程师__Spring学习笔记(待更新)
22 1

相关产品

  • 云迁移中心