Java基础语法

最新推荐文章于 2023-11-04 22:12:33 发布

福伴

最新推荐文章于 2023-11-04 22:12:33 发布

阅读量175

点赞数

原文链接：https://www.cnblogs.com/gussu/p/14615242.html

版权

public class Hello {
public static void main(String[] args) {
//单行注释 //开头
//输出一个Hello World!
System.out.println(“Hello World!”);
/多行注释
我是多行注释
/
/
* 文档注释
* @Description Hello //描述
* @Author 作者
**/
}
}
标识符
关键字

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

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
这些关键字是不能用来，给变量、方法起名字的！

标识符注意点

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

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

不能使用关键字作为变量名

标识符是大小写敏感的，也就是严格区分大小写

合法标识符举例：age、$salary、_value、__1_value

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

public static void main(String[] ages){
String 王者荣耀=“王者荣耀”;//可以使用但不推荐
System.out.print(王者荣耀);
}
可以使用中文命名，但是一般不建议这样使用，也不建议是用拼音，很low!!

2、数据类型
Java是强类型语言

与之相同的还有C/C++都是强类型语言，强类型语言要求变量的使用要严格符合规定，所有的变量都必须先定义后才能使用。

强类型语言的好处就是安全性高，必须定义之后才能使用。缺点就是速度相对来说略有逊色。

public static void main(String[] ages){
String a;
System.out.print(a);//这样书写就会报错，提示必须给a初始化一个值
}

public static void main(String[] ages){
String a=10;//同样会报错，因为String为字符串类型，不能赋值int类型的数据。
System.out.print(a);
}

//正确写法，数据类型要对应

public static void main(String[] ages){
String a =“Hello World”;
System.out.print(a);
}
弱类型语言：

VB、JS都属于弱类型语言，它与强类型语言正好相反，速度相对较快，但是安全性稍微不足。

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

基本类型（primitive type）
引用类型（reference type）
基本类型又分为：

数值类型
整数类型
byte占一个字节范围：-128~127
short占两个字节范围：-32768~32767
int占四个字节范围：-2147483648~2147483647
long占八个字节范围：-9223372036854775808~9223372036854775807
浮点类型
float占四个字节
double占八个字节
字符类型char占两个字节
Boolean类型：占一位其值只有true和false两个
引用数据类型：

类
接口
数组
public static void main(String[] ages){
//八大基本数据类型
int num1 = 10;//最常用
byte num2 = 10;
short num3 = 30;
long num4=100000L;//Long类型要在数字的后面加上L，来区分
//小数，浮点数
float num5 = 40.1F;//float类型也需要在数字后面加上F来与double区分,
double num6 = 40.11;

//字符类型
char name = 'A';//只能写一个字符，如果写多个就会报错，一般用单引号括起来

//String 不是关键字，是类
String str = "你好！";//可以存放字符串类型

//boolean 布尔值:是/非
boolean flag = true;
boolean flag = false;

}
如果说你不懂什么是字节，这里九好评好看看吧！

位(bit):是计算机内部数据存储的最小单位，11001100是一个八位二进制数。

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

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

1bit表示1位

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

1024B= 1KB

1024KB= 1M

1024M = 1G

拓展：

public class Dome01 {
public static void main(String[] args) {
//整数拓展：进制二进制0b 十进制八进制0 十六进制0x
int i = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
//=====================================
//浮点数扩展银行业务如何标识？钱
//BigDecimal 数学工具类
//=====================================
//float 有限离散舍入误差大约接近但不等于
//double
//最好完全不要使用浮点数进行比较
//最好完全不要使用浮点数进行比较
//最好完全不要使用浮点数进行比较

    float f = 0.1f;//0.1
    double d = 1.0/10;//0.1
    
     System.out.println(f==d);//输出为false
     System.out.println(f);//0.1
     System.out.println(d);//0.1
    float d1 = 23232332323232f;
    float d2 = d1 + 1;
     System.out.println(d1==d2);//true
    
    //=====================================
    //字符扩展 
    //=====================================
    char c1 = 'a';
    char c2 = '中';
    System.out.println(c1);
    System.out.println((int)c1);//强制转换
    
    System.out.println(c2);
    System.out.println((int)c2);
    
    //所有的字符的本质还是数字
    //编码 Unicode 表中对应字符和数字 2字节 0-65536 Excel 最长只有 2的16次方 
    char c3='\u0061';
    System.out.println(c3);//a
    //转义字符
    //\t 制表符
    //\n 换行
    // ··· 自行查找
    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为判断条件如果的意思，后面细讲
    if(flag){}这两行代码相同
     //Less is More! 代码要精简易读
}

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

低<--------------------------------------------->高
byte,short,char->int->long->float->double
小数的优先级一定大于整数！所以float大于long

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

问题：

public class Demo05{
public static void main(String[] ages){
int i = 128;
byte b = (byte)i;//强制类型转换，内存溢出

    //强制转换 格式（类型）变量名；
    
    System.out.println(b);//输出-128？
    //这是因为byte本身最高只能为127，赋值128后出现溢出现象
}

}
强制类型转换

格式：（类型）变量名

由高到低强制类型转换（类型）变量名高–低

自动类型转换

自动转换低–高

public class Dome01{
public static void main(String[] ages){
int i = 128;
double d = i;//自动类型转换低–高
System.out.println(d);
/*
注意：
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型，
3.再把大容量转化为低容量的时候–强制转换
4.转换的时候可能会出现内存溢出，或精度问题！
5.
*/
//精度问题
System.out.println((int)23.7);//23
System.out.println((int)-45.89);//45
//==============================
char c = ‘a’;
int d = c+1;
Systerm.out.println(d);//98
Systerm.out.println((char)d);//b
}
}
溢出问题

public class Dome02{
public static void main(String[] ages){
//操作比较大的数的时候，注意溢出问题
//JDK7的新特性，数字之间可以使用下划线分割，为了更方便的观察
int money=10_0000_0000;//下滑线并不会被输出
System.out.println(money);
int years = 20;
int total = moneyyears;
Systerm.out.println(total);//-1474836480,出现溢出现象，超过了int的最大数值
//即便是在计算的时候转换为long，依然会出现错误
long total2 = moneyyears;//默认是int，在转换之前已经溢出。
//解决方案，在计算前就改变类型
long total3 = money*((long)years);
Systerm.out.println(total3);//正确输出

    //另外 在写long数据类型的时候，后缀的L尽量大写，以防认为是1/l
}

}
4、变量、常量
变量
变量是什么：就是可以变化的量！

变量就是只内存空间的一小个位置，我们创建变量就好像在内存空间中申请了一小块位置空间，而空间中存放的东西我们是不确定的。

Java是一种强类型语言，每隔变量都必须生命其类型。

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

type varName [=value] [{,varName[=value]}];
//数据类型变量名 = 值；可以使用逗号隔开来声明多个同类型变量。但是不建议。
注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型（如：String）。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
public class Dome03{
public static void main(String[] ages){
//int a,b,c;不建议
//int a=0,b=2,b=3;//这种写法程序可读性较差，建议分开来写
String name=“Hello”;
char x = ‘x’;
double pi = 3.14;
}
}
变量的作用域

类变量
要求需要加上关键词static。在方法之外，类之内
实例变量
没有关键词，在方法之外，类之内
局部变量
public class Dome03{
//属性：变量
static int allClicks=0;//类变量

String str="Hello World";//实例变量：从属于对象；
//如果不进行初始化，会输出这个类型的默认值
String name;//默认值null
int age;//默认值 0
//布尔值默认为false
//除了基本类型，其余的都是null

//main:方法
public static void main(String[] ages){
    int i = 0;//局部变量:必须声明和初始值
    
    //这里不需要了解很深后面会讲解。
    //变量类型 变量名字 = new Dome03();
    Dome03 dome03 = new Dome03();
    //dome03.name = "Hello";
    Sytem.out.println(dome03.name);
    
    //类变量可以直接在，本类的方法中使用
    System.out.println(allClicks);//0
}

//其他方法
public void add(){
    //这里无法使用 i输出，需要重新定义
}

}
常量
常量（Constant）：初始化（initialize）后不能在改变值！不会变动的值；

常量在定义的时候要使用关键字 final

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

final 常量名 = 值

final double PI = 3.14；

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

public class dome04{
//修饰符，不存在先后顺序
//final static double PI =3.14;也可以
static final double PI =3.14;
public static void main(String[] ages){
System.out.println(PI);
}
}
变量的命名规范：

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：mouthSalary 除了第一个单词以外，后面的单词第一个字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Max，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()
5、运算符
Java语言支持如下运算符：

算数运算符：+，-，，/，%，++，–
%取余原运算，在Java中叫做模运算
赋值运算符：=
关系运算符：>，<,>=,<=,==,!= instanceof
instanceof 到面向对象的时候，再深究
逻辑运算符：&&，||，!
位运算符：&，|，^,~,>>,<<,>>>(了解)
条件运算符：？：
也叫三目运算符，后面在讲，先做了解
扩展赋值运算符：+=，-=，=，/=
//运算符 operator
public class Dome01{
public static void main(String[] ages){
// 二元运算符
//IDEA中快捷键：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/b);//因该等于0.5但是输出为0，这是因为数据类型为int型，会舍去小数部分，所以为0

    //==============================
    long a = 1212312341L;
    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
    //类型转换：byte,short,char用运算符运算后自动转型int类型
    
    //============================
    //关系运算符，返回结果为Boolean类型
    int a = 10;
    int b = 20;
    int c = 21;
    
    //取余也叫做模运算
    System.out.println(c%a);//结果为1，余数为1
    
    System.out.println(a>b);//false
    System.out.println(a<b);//true
    System.out.println(a==b);//false
    System.out.println(a!=b);//true
    
    
    //=============================
    //++ -- 自增，自减 一元运算符
    //a++ = a = a+1 //先运算，a在加一 --相同
    //++a  //a先加1，在运算 --相同
    int a = 3;
    int b = a++; //先给B赋值，在自增
    System.out.println(a);//输出为4
    int c = ++a;//先自增，在给c赋值
    System.out.println(a);//5 
    System.out.println(b);//3
    System.out.println(c);//5 
    
    //=======================
    //幂运算 2^3 2*2*2 = 8
    //但是Java中没有幂运算，也就是没有^这个符号
    //可以是用Math数学工具类，其中包含许多数学方法可以直接使用
    double pow = Math.pow(2,3);
    System.out.println(pow);//8.0
}

}
建议一定要多练习两次++，–的操作达到数来能掌握。

剩下的几种运算符：

逻辑运算

public class Dome04{
public static void main(String[] ages){
//逻辑运算符与（and）或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println(a&&b);//false 有假为假，只有连个都为真的时候才为真
System.out.println(a||b);//true 有真为真，只有都为假的时候才为假
System.out.println(!(a&&b));//true //取反，假的变成真，或者真的变成假

    //当a&&b判断 ,a为假,b为真，当判断出a为假之后程序就会短路，也就是不在判断b的真假，直接执行吓一跳指令。
    //验证
    int c = 5;
    boolean d = (c<<4)&&(c++<4);
    System.out.println(c);//5 //如果执行了后面的语句，c因该输出的为6
    System.out.println(d);//false
}

}
位运算

public class Dome01{
public static void main(String[] ages){
/*
A = 0011 1100
B = 0000 1101

    A&B 按位与运算 0000 1100	有0为0
    A|B 按位或运算 0011 1101	有1为1
    A^B 按位异或运算 0011 0001 相同为0不同为1
    ~B 按位取反	 1111 0010	原来为1取反后为0，原来为0后来为1
    
    2*8 = 16 2*2*2*2
    效率极高
    <<左移	>>右移
    <<	相当于数字*2
    >>	相当于数字/2
    0000 0000
    0000 0001	1
    0000 0010	2
    0000 0011	3
    0000 0100	4
    ··· ···
    0000 1000	8
    0001 0000	16
    */
    System.out.println(2<<3);//输出16
}

}
扩展运算符

public class Dome02{
public static void main(String[] ages){
int a = 10;
int b = 20;

    a += b;//先当与a=a+b;
    a -= b;//相当于a=a-b;
    System.out.println(a);//30
    
    //字符串连接符 +
    System.out.println(a+b);//用作字符运算
    System.out.println(""+a+b);//输出1020
    //如果在加号前边出现""字符类型，那么将会将字符串后的，所有运算数据转化为字符串类型进行连接，前面的运算按照正常进行。
    System.out.println(a+b+"");//30
    //运算过程是从左向右
    
    //=================================
    //三元运算符//
    //必须掌握，实际开发中经常使用
    //x ? y : z
    //如果x==true,结果为y，否则结果为z
    
    int score = 80;
    String type = socre < 60? "不及格":"及格了";
    System.out.println(type);//输出及格
}

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

包的本质：就是文件夹！

包语句的语法格式为：

package pkg1[. pkg2[. pkg3…]];
一般利用公司域名倒置作为包名；例如：com.baidu.www

为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import完成此功能

import package1[.package2…].(classname|*);
导入包的时候的快捷键：ALT+回车

总结：

定义包用package
导入包用import
当一个包中有许多类，可以直接通过通配符全部导入
例如：com.baidu.www.
推荐看完这章后，去看一下阿里巴巴开发手册！，百度搜索就行

JavaDoc
传送门：jdk帮助文档

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

参数信息

@author 作者名
@version 版本号
@since 指名需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
//加载类上面就是类的注释
/**

@author zhao
@version 1.0
@since 15

/
public class Dome02 {
String name;
//加载方法上面就是方法的注释
/*
* @author zhao
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
}
USB Microphone https://www.soft-voice.com/
Wooden Speakers https://www.zeshuiplatform.com/
亚马逊测评 www.yisuping.cn
深圳网站建设www.sz886.com