Java基础 - 入门

断痕

发布于 2021-01-21 14:51:42

8820

发布于 2021-01-21 14:51:42

文章被收录于专栏：edlcloud

Java基础 - 【入门】

首先来一个Hello,World!

public class HelloWorld {
    public static void main(String[] ages){		//创建快捷键psvm
        //单行注释
        /* 多行注释 */
        /**
         *@Description 文档注释
         */
        System.out.println("hello,world");
    }
}

三种注释方式

//单行注释

/* 多行注释 */

/** 文档注释 */		# 注释内可以使用@+参数 JavaDoc文档注释

IDEA更改注释颜色

Block comment		# 多行注释

JavaDoc				# 文档注释

Line comment		# 单行注释

标识符

关键字

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

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

表示类名的标识符用大写字母开始

例：Man,GoodMan

表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始

例：eat(),eatFood()		//驼峰命名法

关于 Java 标识符，有以下几点需要注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符大小写敏感
合法标识符举例：value、$value、_value、__1_value
非法标识符举例：123value、-value、#value

public class HelloWorld {
    public static void main(String[] ages){
        //合法标识符
        String value;
        String $value;
        String _value;
        String __1_value;
        //不合法标识符
        String 123value;
        String value;
        String #value;
    }
}

JAVA不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集

各种字符集和编码详解

数据类型

强弱类型语言

也称为强类型定义语言

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

Java、.NET、C++等都是强制类型定义的

也就是说，一旦一个变量被指定了某个数据类型，如果不经过转换，那么它就永远是这个数据类型了

安全性高，运行效率相对较慢，鱼和熊掌不可兼得

强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误

弱类型语言

也称为弱类型定义语言

与强类型定义相反，像vb，php等就属于弱类型语言，在VBScript中，可以将字符串'12'和整数3进行连接得到字符串'123'，也可以把它看成整数123，而不需要显示转换

但其实它们的类型没有改变，VB只是在判断出一个表达式含有不同类型的变量之后，自动在这些变量前加了一个clong()或(nt)()这样的转换函数而已

能做到这一点其实是归功于VB的编译器的智能化而已，这并非是VB语言本身的长处或短处

Java的数据类型分为两大类：

基本类型（primitive type）

引用类型（reference type）

基本数据类型

public class HelloWorld {
    
    public static void main(String[] args) {

    //整数
    int   num1 = 1;
    byte  num2 = 2;
    short num3 = 3;
    long  num4 = 4L; //可以在long类型后面加一个L来标识一下，L不会被输出。

    //浮点数
    float num5 = 1.1F; //需要在后面加F
    double num6 = 1.2;

    //字符数
    char name = 'a'; //他只能是一个字符比如 char name = 'ab';就是错误的
    String name1 = "随意";

    //布尔值
    boolean flag = true;
    boolean flag1 = false;
    }
}

类型	字节	表示范围
byte（字节型）	1	-128～127
short（短整型）	2	-32768～32767
int（整型）	4	2147483648～2147483647
long（长整型）	8	-9223372036854775808 ~ 9223372036854775807
float（浮点型）	4	-3.4E38～3.4E38
double（双精度型）	8	-1.7E308～1.7E308
char（字符型）	2	从字符型对应的整型数来划分，其表示范围是0～6553
boolean（布尔型）	1	true/false

查看具体范围代码

public static void main(String[] args) {

        // byte
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        // short
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        // int
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        // long
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        // float
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        // double
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        // char
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");

        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE="
                + (int) Character.MIN_VALUE);

        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值：Character.MAX_VALUE="
                + (int) Character.MAX_VALUE);
    
    }

/*
    位（bit）：是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。

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

    1B（byte,字节）= 8bit（位）

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

    ASCIIS码：

        1个英文字母（不分大小写）= 1个字节的空间
        1个中文汉字 = 2个字节的空间
        1个ASCII码 = 一个字节

    UTF-8编码：

        1个英文字符 = 1个字节
        英文标点 = 1个字节
        1个中文（含繁体） = 3个字节
        中文标点 = 3个字节

    Unicode编码：

        1个英文字符 = 2个字节
        英文标点 = 2个字节
        1个中文（含繁体） = 2个字节
        中文标点 = 2个字节

    1bit表示1位，
    1Byte表示一个字节 1B=8b。
    1024B=1KB
    1024KB=1M
    1024M=1GB
*/

进制：一般分为

十进制
八进制
十六进制

十进制整数，如：99, -500, 0

八进制整数，要求以 0 开头，如：010

十六进制数，要求 0x 或 0X 开头，如：0x10

浮点型

浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。
如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类

主要理由：

由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的

浮点数一般都存在舍入误差，很多数字无法精确表示，其结果只能是接近，但不等于

二进制浮点数不能精确的表示0.1,0.01,0.001这样10的负次幂

并不是所有的小数都能可以精确的用二进制浮点数表示

最好完全避免使用浮点数比较

大数值：Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值

BigInteger实现了任意精度的整数运算

BigDecimal实现了任意精度的浮点运算

浮点数使用总结：

默认是double
浮点数存在舍入误差，很多数字不能精确表示
如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类
避免比较中使用浮点数

字符型

单引号用来表示字符常量

例如'A'是一个字符，它与"A"是不同的，"A"表示一个字符串

char类型用来表示在Unicode编码表中的字符

Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符

科普：2字节=16位 2的16次方=65536，我们用的Excel原来就只有这么多行，并不是无限的

Unicode具有从0到65535之间的编码，他们通常用从'u0000’到'uFFFF'之间的十六进制值来表示（前缀为 u表示Unicode）

Java 语言中还允许使用转义字符,来将其后的字符转变为其它的含义，有如下常用转义字符

char c3 = '\u0061';
System.out.println(c3); //a

Java 语言中还允许使用转义字符，来将其后的字符转变为其它的含义，有如下常用转义字符

布尔型

boolean类型（一位，不是一个字节），就是0|1 boolean类型有两个值，true和false，不可以 0 或非 0 的整数替代true和false，这点和C语言不同

boolean 类型用来判断逻辑条件，一般用于程序流程控制

总结代码如下

public static void main(String[] args) {
        //整数扩展: 进制      二进制0b       十进制     八进制0        十六进制0x

        int i = 10;
        int i1 = 010;   //八进制0
        int i2 = 0x10;  //十六进制0x    0~9 A~F 16
        int i3 = 0x11;  //0~9 A~F 16

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=======================");

        //============================
        //浮点数扩展:    银行业务怎么表示。
        //BigDecimal   数学工具类
        //============================

        float f = 0.1f; //0.1
        double d = 1.0/10;  //0.1

        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);

        //float 有限  离散  舍入误差    大约  接近但不等于
        //double
        //避免完全使用浮点数进行比较
        float f1 = 213213213321f;
        float f2 = f1 +1 ;
        System.out.println(f1==f2);
        System.out.println("=======================");

        //============================
        //字符数扩展:
        //============================

        char c1 = 'a';
        char c2 = 'A';

        System.out.println(c1);
        System.out.println(c2);

        System.out.println((int)c1); //强制转换数字
        System.out.println((int)c2);

        //所有字符的本质还是数据
        //编码 Unicode 表：(97 = a 65 = A) 2字节  范围是 0 - 65536   Excel 单元格的最大字节数是 2的16次方 是65536

        //U0000 UFFFF

        char c3 = '\u0061';
        System.out.println(c3); //a
        System.out.println("=======================");

        //转义字符
        // \t   水平制表符
        // \n   换行
        //....更多自行百度

        System.out.println("Hello\nWorld");
        System.out.println("=======================");

        String sa = new String("helloworld");
        String sb = new String("helloworld");
        System.out.println(sa == sb);

        String sc = ("helloworld");
        String sd = ("helloworld");
        System.out.println(sc == sd);

        //============================
        //布尔值扩展:
        //============================

        boolean flag = true;
        //下面两个实现功能是相等的
        if(flag == true){}

        if (flag){}

        //Java名言 Less is More! 代码要精简易读
    }

类型转换

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

整型、实型（常量）、字符型数据可以混合运算

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

转换从低级到高级（根据容量来看）

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换

不能把对象类型转换成不相关类的对象

在把容量大的类型转换为容量小的类型时必须使用强制类型转换

转换过程中可能导致溢出或损失精度，例如：

int i =128;
byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出

浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如

(int)21.6 == 21;
(int)-21.32f == -21;

自动类型转换

容量小的数据类型可以自动转换为容量大的数据类型

例: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为 32，可以自动转换为64位的double类型

强制类型转换

强制类型转换，又被称为造型，用于显式的转换一个数值的类型，在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出

强制类型转换的语法格式： (type)var ，运算符"()"中的type表示将值var想要转换成的目标数据类型

条件是转换的数据类型必须是兼容的

public static void main(String[] args) {
	
    double x = 3.14;
	int nx = (int)x; //值为3
    
	char c = 'a';
    int i2 = c;
    int i3 = c + 1;
    System.out.println(i2); //97
    System.out.println((char)i2);//a
    System.out.println(i3); //98
    System.out.println((char)i3); //b
}

当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值，溢出

public static void main(String[] args) {
	int x = 300;
	byte bx = (byte)x; //值为44
	
    System.out.println(bx);
}

常见错误和问题

操作比较大的数时，要留意是否溢出，尤其是整数操作时

public static void main(String[] args) {
        int money = 10_0000_0000; //10亿
        int years = 20;
        int total = money * years; //返回的是负数,-1474836480 内存溢出
        long tota2 = money * years; //返回的仍然是负数。1474836480 默认是int 因此结果会转成int值  再转成long 但是已经发生了数据丢失
        long tota3 = (long)money * years; //先将一个因子变成long，整个表达式发生提升。全部用long来计算。
        long tota4 = money * (long)years;
        
        System.out.println(total); // -1474836480
        System.out.println(tota2); // -1474836480
        System.out.println(tota3); // 20000000000
        System.out.println(tota4); // 20000000000
    }

L和l的问题：

不要命名名字为l的变量
long类型使用大写L不要用小写。

public static void main(String[] args) {
	int l = 2;
	
    long a = 23451l; //l长得特别象1

    System.out.println(l+1); //3
    
	System.out.println(a); //23451
}

Jdk7扩展

JDK7新特性: 二进制整数

由于我们在开发中也经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型

我们只要以：0b开头即可

int a = 0b0101;	// 5

JDK7新特性：下划线分隔符

在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼，JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割

int b = 1_2234_5678; //也是122345678

很容易就知道这是1亿2234万5678，好阅读

总结代码

public static void main(String[] args) {

        int i = 128;

        //强制类型转换    (类型)变量名 高 -> 低
        byte b = (byte) i;
        System.out.println(b);

        //自动转换  低 -> 高
        double d = i;
        System.out.println(d);

        System.out.println("=======================");

        /*
        注意点
        1. 不能对布尔值进行转换
        2. 不能把对象类型转换为不相干类型
        3. 再把高容量转换到低容量的时候，使用强制转换
        4. 转换的时候可能存在内存溢出，或者精度问题 第一个例子就是内存溢出
         */

        System.out.println((int)21.6); //等于21，没有四舍五入
        System.out.println((int)-21.32f);//等于21

        System.out.println("=======================");

        char c = 'a';
        int i2 = c;
        int i3 = c + 1;
        System.out.println(i2);
        System.out.println((char)i2);
        System.out.println(i3);
        System.out.println((char)i3);
    }

public static void main(String[] args) {

        //操作比较大的数的时候，注意溢出问题
        //JDK7 新特性，数字之间可以用下划线分割

        int money = 10_0000_0000; //10亿
        int years = 20;
        int total = money * years; //-1474836480内存溢出
        long tota2 = money * years; //-1474836480内存溢出

        System.out.println(total);
        System.out.println(tota2);

        long tota3 = (long)money * years; //20000000000 OK
        long tota4 = money * (long)years; //20000000000 OK
        System.out.println(tota3);
        System.out.println(tota4);
    
        int a = 0b0101;
        System.out.println(a); //5
    }

变量

变量就是可以变化的量

Java是一种强类型语言，每个变量都必须声明类型

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

type name = [value];

注意

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

变量作用域

类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰
局部变量（lacal variable）：类的方法中的变量

public class Demo08 {
    //类变量
    static double d = 2000; //int自动变double
    //实例变量
    String s;
    String s1 = "实例变量";

    public static void main(String[] args) {
        //局部变量
        int i = 1;
    }
}

局部变量

方法或语句块内部定义的变量

**生命周期是从声明位置开始到"}"**为止

在使用前必须先声明和初始化(赋初值)

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用

public class Demo08 {

    public static void main(String[] args) {

        //局部变量
        int i; //在方法内没有赋值的变量
        //System.out.println(i); //i会报错
		
    	//正确
    	int i = 1;
    	System.out.println(i);
	}
}

实例变量

方法外部、类的内部定义的变量

从属于对象，生命周期伴随对象始终

如果不自行初始化，他会自动初始化成该类型的默认初始值

数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false

静态变量

使用static定义

从属于类，生命周期伴随类始终，从类加载到卸载

如果不自行初始化，他会自动初始化成该类型的默认初始值

数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false

public class Demo08 {

    //类变量
    static double d = 2000; //int自动变double
    //d1 是私有类变量
    private static double d1 = 2100;

    public static void main(String[] args) {

        //类变量可以直接在方法中使用
        System.out.println(d); //2000.0
    }
}

变量总结

public class Demo08 {

    //类变量
    static double d = 2000; //int自动变double
    //d1 是私有类变量
    private static double d1 = 2100;

    //实例变量
    public String s; //未赋值 可以直接输出默认值 实例变量对子类可见
    private int b;// 私有变量，仅在该类可见

    public static void main(String[] args) {

        //类变量可以直接在方法中使用
        System.out.println(d); //2000.0

        //局部变量
        int i; //在方法内没有赋值的变量
        int i1 = 1;
        //System.out.println(i); //i会报错
        System.out.println(i1); //正确

    }
}

常量

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

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

语法

final 类型 常量名(大写) = 值;

public class Demo09 {

    //常量
    final String NI = "1";

    static final String NO = "2";

    final static String NP = "3";

    public static final String NJ = "4";

    private final String NK = "5";
    
    public static void main (String[] args){

        // System.out.println(NI); //错误
        System.out.println(NO); // 2
        System.out.println(NP); // 3
        System.out.println(NJ); // 4
        // System.out.println(NK); //错误
    }

}

常量名一般使用大写字符

变量常量命名规范

所有变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则 : monthSalary

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线：MAX_VALUE

类名：首字母大写和驼峰原则: Man, GoodMan

方法名：首字母小写和驼峰原则: run(), runRun()

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2020-09-12，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

java

数据结构

c++

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度

Java基础 - 入门

Java基础 - 入门

Java基础 - 【入门】

首先来一个Hello,World!

三种注释方式

IDEA更改注释颜色

标识符

关键字

关于 Java 标识符，有以下几点需要注意：

数据类型

强弱类型语言

弱类型语言

Java的数据类型分为两大类：

基本数据类型

进制：一般分为

浮点型

字符型

布尔型

类型转换

自动类型转换

强制类型转换

常见错误和问题

Jdk7扩展

变量

变量作用域

局部变量

实例变量

静态变量

变量总结

常量

变量常量命名规范

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐