Java基础语法
1.注释、标识符、关键字
注释
当项目结构复杂的时候，需要用到注释，书写注释是一个非常好的习惯，让程序代码更加规范。注释是不会被执行的，是给写代码的人看的！平时写代码一定要注意代码规范！
Java中注释分为三种：
- 单行注释
- 多行注释
- 文档注释
package 基础语法;
public class HelloWorld {
public static void main(String[] args) {
//输出一个hello，world
//单行注释：可以注释一行文字 //
System.out.println("Hello,World!");
//多行注释：可以注释一段文字 /* 注释 */
/*
我是多行注释
我是多行注释
*/
//JavaDoc：文档注释 /** */
/**
* @author 41122
*/
}
}
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
标识符注意点
- 所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（_）开始。
- 首字符之后可以是字母（A-Z或者a-z）、美元符（$）、或者下划线（_）或数字的任何字符组合。
- 不能使用关键词作为变量名或方法名。
- 标识符是大小写敏感的。
- 合法标识符举例：age, $salary, _value, _1value
- 非法标识符举例：123abc, -salary, #abc
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很low。
关键词
2.数据类型
数据类型
Java属于强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。（如果不经过转换，则永远是这个类型）这样保证了Java的安全性高，但是速度慢
public class Demo01 {
public static void main(String[] args) {
String a;
System.out.println(a);
}
}
在上述代码中，没有给a进行变量定义，则程序会报错，The local variable a may not have been initialized
数据类型的分类
- 基本类型(primitive type)
- 引用类型(reference type)
以下为Java的基础数据类型的代码展示：
package 基础语法;
public class Demo01 {
public static void main(String[] args) {
//八大基本数据类型
//整数
int num1 = 10;//最常用
byte num2 = 20;
short num3 = 20;
long num4 = 30L;//Long类型要在数字后面加一个L来明确其类型
//小数：浮点数
float num5 = 50.1F;//float类型要在数字后面加一个F来明确其类型
double num6 = 3.14159265358979323;
//字符
char name = '请';//字符要用单引号
//字符串，String不是关键词，是类
//String name1 = "梦想";
//布尔值：代表是非
boolean flag = true;
//boolean flag = false;
}
}
拓展
字节
- 位(bit):是计算机内部数据存储的最小单位，11001100是一个八位二进制数
- 字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示
- 1B(byte，字节) = 8bit(位)
- 字符：是指计算机中使用的字母、数字、字和符号
常见的换算：
- 1bit表示1位
- 1Byte表示一个字节1B=8b
- 1024B = 1KB
- 1024KB = 1M
- 1024M = 1G
- 1024G = 1T
数据类型拓展
package 基础语法;
public class Demo02 {
public static void main(String[] args) {
//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;//八进制
int i3 = 0x10;//十六进制 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("==========================");
//==========================================================
//浮点数拓展？ 银行业务怎么表示？钱——————BigDecimal 数学工具类
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//==========================================================
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);//false
System.out.println(f);
System.out.println(d);
float d1 = 2453434534565f;
float d2 = d1 + 1;
System.out.println(d1==d2);//true
System.out.println("==========================");
//==========================================================
//字符拓展？
//==========================================================
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int)c1);//强制转换
System.out.println(c2);
System.out.println((int)c2);//强制转换
//所有的字符本质还是数字
//编码 Unicode表：(97=a，65=A) 2字节 0-65536
//U0000 UFFFF
char c3 = '\u0061';
System.out.println(c3);//a
//转义字符
// \t 制表符
// \n 换行
//......还有很多
System.out.println("Hello\tWorld");//Hello World
boolean flag = true;
if (flag==true) {}//新手
if (flag) {}//老手
//Less is more! 代码要精简易读
}
}
3.类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。运算中，不同类型的数据先转化为同一类型，然后进行运算
//低---------------------------------------------->高(小数的优先级一定是大于整数)
//byte，short，char -> int -> long(64) -> float(32) -> double
类型转换代码
具体的转换的代码展示：
package 基础语法;
public class Demo03 {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i;//内存溢出
//强制转换 （类型）变量名 高->低
//自动转换 低->高
System.out.println(i);//128
System.out.println(b);//-128 强制转换而导致内存溢出
int i2 = 128;
double b2 = i;
//强制转换 （类型）变量名 高->低
//自动转换 低->高
System.out.println(i2);//128
System.out.println(b2);//128.0 自动转换
/*
* 1.不能对布尔值进行转换
* 2.不能把对象类型转换为不相干的类型
* 3.在把高容量转换到低容量的时候，强制转换
* 4.转换的时候可能存在内存溢出，或者精度问题！
*/
System.out.println("========================");
System.out.println((int)23.7);//double类型转换为int类型 23
System.out.println((int)-45.89f);//float类型转换为int类型 -45
System.out.println("========================");
char c = 'a';
int d = c + 1;
System.out.println(d);//98
System.out.println((char)d);//b
}
}
类型之间的常见计算问题
package 基础语法;
public class Demo04 {
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割，且不会被输出
int money = 10_0000_0000;
System.out.println(money);
int years = 20;
//int total = money*years; //-1474836480,计算的时候溢出
//long total2 = money*years; //默认是int，转换之前已经存在问题了，所以还是会是同样的值
long total3 = money*((long)years);
System.out.println(total3);
}
}
4.变量、常量
变量
变量的概念
- 变量的概念：可以变化的量。(变量是指有一个空间，但是里面的东西不确定，但是位置是确定的，本身存在)
- Java是一种强类型语言，每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName [=value][{,varName[=value]}];
//数据类型 变量名=值；可以用逗号隔开来生命多个同类型变量。(但是不建议在一行里面定义多个值)
注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
public class Demo05 {
public static void main(String[] args) {
//int a, b, c; //不建议一行定义多个变量
//int a = 1,b = 2,c = 3; //要保证程序的可读性
String name = "meng";
char x = 'X';
double pi = 3.14;
}
}
变量作用域
- 类变量
- 实例变量
- 局部变量
public class Demo06 {//这是在一个类里面写东西
//类变量 static
static double salary = 2500;
//可以在类里面定义属性：变量
//实例变量：从属于对象（对象是问题域中客观存在事物的抽象，是一组属性和在这组属性上的封装体）
//如果实例变量不进行初始化，这个类型的默认值0或者0.0或u0000
//布尔值默认为false
//除了基本类型，其余的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须声明和初始化值(写了之后可以直接使用)
int i = 10;
System.out.println(i);
//变量类型 变量名字 =new Demo06
Demo06 demo06 = new Demo06();//new就是在内存中开辟了一块空间，可以对里面的数据进行操作Alt+Shift+L
System.out.println(demo06.age);//Ctrl+Alt+下标为复制这一行到下一行
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add() {}
}
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary(除了第一个单词以外，后面的单词首字母大写 lastName )
- 局部变量：首字母小写和驼峰原则
- 常量：全部大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和驼峰原则：run(), runRun()
常量
- 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
- 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值；
final double PI = 3.14；
- 常量名一般使用大写字符。
public class Demo07 {
//修饰符，不存在先后顺序，通过final来定义常量
final static double PI = 3.14;
//static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
5.运算符
Java语言支持如下运算符：（重点掌握前面四种运算符）**优先级()**用小括号去灵活控制程序运行的优先级，养成良好的代码规范
- 算数运算符 + , - , * , / , %（取余） , ++ , –
- 赋值运算符 =
- 关系运算符 > , < , >= , <= , == , !=（不等于）， instanceof（判断一个对象是否是一个类的实例）
- 逻辑运算符 &&（与） , ||（或） , !（非）
- 位（二进制）运算符 & , | , ^ , ~ , >> , << , >>>
- 条件运算符 ? :
- 扩展赋值运算符 += , -= , *= , /=
运算符的代码运算
package operator;
public class Demo01 {
public static void main(String[] args) {
//二元运算符
//Ctrl+Alt+下键 ：复制当前行到下一行
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);//两个int相除会出现0的状况，则需要选择其一转换类型
}
}
package operator;
public class Demo02 {
public static void main(String[] args) {
long a = 1243534523424325L;
int b = 123;
short c =10;
byte d = 8;
System.out.println(a+b+c+d);//Long（有Long的时候为Long）
System.out.println(b+c+d);//Int（没有Long的时候都为Int类型）
System.out.println(c+d);//Int cast转换
//以int为分界线。没有long，float，double时，byte，short，char这三个运算会提升到int，如果有long，float，double则提到这里面最高等级的一个
}
}
package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符返回的结果：正确，错误 布尔值
int a = 10;
int b = 20;
int c = 21;
//取余，模运算
System.out.println(c%a);
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
}
}
package operator;
public class Demo04 {
public static void main(String[] args) {
//++ -- 自增，自减 一元运算符
int a = 3;
int b = a++;//执行完这行代码后，先给b赋值，再自增
//a++ a=a+1
System.out.println(a);
//++a a=a+1
int c = ++a;//执行完这行代码后，先自增，再给b赋值（重点是执行的时机不同）
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 很多运算可以使用工具类来操作
double pow = Math.pow(2, 3);//Alt+Shift+L
System.out.println(pow);
}
}
package operator;
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
//与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b:"+(a||b));//逻辑或运算：两个变量有一个为真，则结果才为true
System.out.println("!(a && b):"+(!(a&&b)));//如果是真，则变为假，如果是假，则变为真
//短路运算,如果逻辑与运算中，第一个为假，则不会执行第二个运算
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
}
}
package operator;
public class Demo06 {
public static void main(String[] args) {
/*
* A = 0011 1100
* B = 0000 1101
*
* A&B = 0000 1100（对应位置全是1的时候才为1）
* A|B = 0011 1101（对应有1则是1）
* A^B = 0011 0001（异或：相同为0，不同为1）
* ~B = 1111 0010（取反）
*
* 计算机组成原理
* 2*8如何计算是最快的=16 2*2*2*2
* << *2
* >> /2
*/
System.out.println(2<<3);
}
}
package operator;
public class Demo07 {
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);
System.out.println(""+a+b);//引号内容为空,引号在前面则进行拼接
System.out.println(a+b+"");//引号内容为空，引号在后面则仍进行计算
}
}
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
//x？y：z
//如果x=true，则结果为y，否则结果为z
int score = 50;//改变数值则可以进行选择
String type = score <60?"不及格":"及格";//必须掌握，让代码更加精简
System.out.println(type);
}
}
6.包机制、JavaDoc
包机制
- 为了更好地组织类，Java提供包机制，用于区别类名的命名空间(包的本质就是文件夹)
- 包语句的语法格式为：
package pkg1[. pkg2[. pkg3...]];
- 一般利用公司域名倒置作为包名；例如www.baidu.com 为 com.baidu.www
- 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用 “import” 语句可以完成此功能
import package1[.package2...].(classname|*);
- *表示通配符，例如下，可以将一个包里的全部文件给导入进来
import com.fulusoul.base.*;
//导入这个包下所有的类！
可以看《阿里巴巴开发手册》去了解规范。无规范不成方圆，无规范不能协作。
JavaDoc
- JavaDoc命令是用来生成自己API文档的
- 参数信息
-
- @author 作者名
- @version 版本名
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
- 加在类上面，就是类的注解；加在方法上面，就是方法的注解
package 基础语法;
/*
* @author fulusoul
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;//属性
/**
*
* @param name参数
* @return返回值
*/
//输入"/**"之后按住回车会直接弹出上述的内容
/**
*
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;//方法
}
//视频讲解通过命令行 javadoc 参数 Java文件
//作业：学会查找使用IDEA生产JavaDoc文档！ 面向百度编程，遇到不会可以百度！
}
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
