JAVASE：基础语法总结

来源：99网

JAVASE基础语法总结

一.JAVA历史

1991年为oak,主要是做电子嵌入式产品，但因c语言技术相对成熟而被雪藏。实用性低。直至1993年IE浏览器的出现成就了oak,后改为JAVA。

1.1 JAVA的语言体系

JAVASE- - -语言的一些基本语法和用法主做pc端和客户端程序
JAVAEE- - -主要应用于WEB及浏览器应用级项目 OA SAAS ERP等
JAVAME- - -塞班系统 Android系统的出现
大数据相关的hadoop的源码是java

1.2 JAVA语言的特点

跨平台：
java是运行在JVM虚拟机上的，而不同的平台会有不同的JVM虚拟机，虚拟机是跨平台的，故而JAVA语言跨平台

1.3 JAVA的环境安装

1. jdk安装

Jdkjavadevelopmentkit JAVA的开发工具包
Jdk----java的开发工具
Jre-----java RunTimeenvironmentjava的运行时环境
一般安装JDK时都会自动安装Jre

2. 环境变量配置

在安装好JDK后还需要在 - - 我的电脑 ----属性 - - -高级系统设置 - - - -环境变量- - - 配置环境变量
分别是JAVA_HOME，Path和class_path

配置好后再CMD中用java -version，Java，javac检测是否配置完成即可

1.4java程序

你的HelloWrold编写完后是.java文件（源代码文件）。需要在CMD中通过javac命令编译成.class文件(字节码文件),方可用java命令运行

1.5JVM运行原理

源代码文件通过javac编译成字节码文件后。传入JVM虚拟机，在通关调用JVM中的java类库传入类加载器（classLoader）加载传入字节码解释器和JIT即时编译器后一起传输至执行引擎通过os硬件执行。
JVM在底层执行的class文件都是二进制文件

1.6代码的简单分析

//访问修饰符 类关键字 类名
public class HelloWorld {
	
	// 主函数  主方法  -----整个程序的入口
	// 4要素 1-public  2 static 3 void 4 方法名称必须叫main
	public static void main(String [] args){
	    // 打印语句
        //类.属性.方法 带()都叫方法
		System.out.println("Hello Java");
	}
}

二.语言的常用规范

2.1类的命名规范

2.2注释

注释分为单行注释和多行注释以及文档说明注释

//单行注释

/*
多行注释1
多行注释1
*/
/**
   *文档注释
   * @author maclu   作者
    * @since 2021.5.9 时间
    * @param args
    * @return返回值
    * @throws抛出异常

*/

2.3 包的创建命名规范

关键字 package一般命名规范是公司域名的反写，包的主要作用就是为了在不同文件夹下存在相同的文件名称。

2.4换行，制表位和扫描器Scanner

\n换行至下一行
\t一个Tap的位置–制表位
Scanner扫描器。用于输入。

package com.openlab.test;
import java.util.Scanner;
publicclass HelloWorld {
	publicstaticvoid main(String[] args) {	
		System.out.println("请输入您的角色名：");
		//创建Scanner对象
		Scanner input = new Scanner(System.in);
		String key = input.nextLine();	
		System.out.println(key);
	}
}

2.5方法

静态方法不能直接调用费静态方法，需要通过对象调用
方法可以反回指定的类型
void只无返回数据，int为返回整形以此同理
若不是void则·需要返回值或者变量，对象等。视情况返回。

三.数据类型----重点

3.1基本数据类型

3.1.1整形

byte 字节型 1个字节 -128~127 占8个bit（00000001）默认值为0
short 短整型 2字节占16个bit 默认值为0
int 整型 4个字节占 32个bit，默认值为0.
Long 长整型占个bit八个字节，默认值0L
长整形值需要加上大写的L字符；

3.1.2浮点型

float 单精度 4个字节 32个bit 默认值0.0f 值的后面带默认符号f
double 双精度 8个字节个bit 默认值0.0

3.1.3字符型

char 标识是单引号用于表示单个字符会存在数字字母特殊符号以及文字占16个bit 2个字节取值范围：0x0000~0xffff默认值是0x0000；

3.1.4布尔型

boolean 占8个bit 1个字节默认值false 值只能为true或者false

面试重点和类型转换

面试题：String是不是基本数据类型如果不是基本数据类型有哪些？
String是字符串类型 -----引用数据类型不是基本数据类型
小类型转大类型自动转换，大类型转小类型需要强制转换。

char可以和byte类型转换：以ASCII码的形式转换
boolean 不能和任何类型转换

3.2 变量

变量的定义：一般情况下指的程序中需要计算的数据通过开辟内存空间而存储的数据，这个数据是通过某种媒介来进行访问用来存储数据的媒介叫变量

成员变量的定义

在类的里面方法的外面的变量叫做成员变量成员变量存在堆中(heap)，不会随着方法的结束而消失

局部变量的定义

在方法的里面的变量叫做局部变量。局部变量存在栈空间之中。由栈创建，会随着方法的结束而消失。局部变量不能使用static关键词修饰

package HashCode;
public class Test {
	public static int a=0;
	public static void main(String[] args) {
		Test.student();}	
	public static void student(){
		int b=1;
		b=a}
}

3.3复合数据类型----引用数据类型

非基本数据类型都是引用数据类型。例如（String）

3.4 变量的命名规范

不要使用中文，韩文，日文等当做类名
首字母小写(驼峰式命名法),名字望文生义
不能使用数字开头
不能使用关键字
除了_和$符号的特殊符号
在同一作用域内不能出现两个相同命名的变量

四.运算符–重点

4.1算术运算符

+ 加
- 减
* 乘
/ 除
% 求余

10%3 = 1
7%5 ----2
7%-5 ----(2)
-7%5 ----(-2)
-7%-5 ----(-2)
总结 ：求余时 负号跟着被除数走。

4.2 递增·递减

`+
+`` – `

//练习
		int a = 9;
		int b = 2;
		int c = a+++b;
		int d = ++a+c++;
		int e = a+++c++;
		//  a-9 b-2 c-12 d-22 e-22
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);

++放前面先+1 再取值
++放后面先取值再+1；

4.3 逻辑运算符

& 逻辑与 a&b 表达式a或b中有一个为false 则为false
&& 短路与 a为false b则不参与运算常用
| 逻辑或 a|b 表达式a或b中有一个为true 则为true
|| 短路或 a为true 则b不参与运算常用
^ 逻辑异或 a|b 表达式a与表达式b两者的值相同则为fasle 不同为true
！逻辑非取反
逻辑运算符的返回值是boolean类型

4.4 赋值运算符

= ：运算顺序是从右至左 int a = 0；
+=：a+=1 ----a = a+1;
-=：a-=1------a=a-1
*=：a*=2------a=a*2
/=：a/=2-------a=a/2

4.5 关系运算符

> >= 大于大于等于
< <= 小于小于等于
== 恒等用于判定两个基本数据类型的值是否相同
!= 不等

4.6 三目运算符

X?Y:Z
表达式X的值如果为true 则执行表达式Y 如果为false 则执行表达式Z
可以用于替代if选择分支语句结构。

equals方法用于比较两个String是否相同。。。。且该方法来自于String类中的equals

面试题：
== 和equals的区别？

4.7 位运算和移位运算

运算结果 ----数字
位运算和移位运算都要在二进制的基础之上运算

&
按位与 两位都为1时结果才为1 有一个位0都落0
5&13

0101
1101
-------.
0101

|
按位或 一个位1都为1
0101
1101
-------.
1101

^
按位异或
两位相同为0 相异为1
5^13

0101
1101
-------.
1000
~ 取反 ~5

正整数的二进制可以通过运算来获得负数的二进制应该如何运算：

-5的二进制码 = 5的二进制取反+1 补码
反码

>> 右移
各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移）

13>>2 右移之后结果是3
128 >> 4
1000
8
右移特点 数字越来越小移位是除以2的多少次幂
-13>>2

<< 左移
3<<2
3<<2
1100 —12

3<<3
11000----24

左移特点 数字越变越大，移位是多少就是乘以2的多少次幂左移时不分正负
如果是整数正常补0
如果是负数则用整数的补码进行运算

>>> 无符号右移
逻辑右移 不会因为符号位进行所有高位均补0。

五.流程控制–重点

按照代码执行顺序来进行执行 ----顺序执行
选择分支 if -else switch
循环结构 while do-while for

5.1 选择分支if

if(x == 0){
			System.out.println("yes");
			 if(x == 1){
				 System.out.println("yes1");
			 }
		}else if(x==1){
			System.out.println("no");
		}

练习：写一个方法：宠物的攻击属性对应宠物的属性会产生不同克制的暴击伤害。

//if判断练习
import java.util.Scanner;
public class PocketMonster {
    public static final String COMMNOLY="一般";//一般
    public static final String COMBAT="格斗";//格斗
    public static final String FLIGHT="飞行";//飞行
    public static final String POISON="毒";//毒
    public static final String EARTH="地上";//地上
    public static final String ROCK="岩石";//岩石
    public static final String INSECT="虫";//虫
    public static final String GHOST="幽灵";//幽灵
    public static final String STEEL="钢";//钢
    public static final String FIRE="炎";//炎系
    public static final String WATER="水";//水系
    public static final String GRASS="草";//草
    public static final String ELECTRIC="电";//电
    public static final String SUPER="超能";//超能
    public static final String ICE="冰";//冰
    public static final String LOONG="龙";//龙
    public static final String EVIL="恶";//恶
    public static final String GOBLIN="妖精";//妖精

    //技能伤害  1为一半伤害
    public static final int ZERO=0;
    public static final int HALF=1;
    public static final int DOUBLE=2;
    public static final int TWOFOLD=4;

    private static String skill;    //宠物技能
    private static String enemy;    //宠物属性


    PocketMonster(String enemy,String skill){  //宠物对象
        this.enemy=enemy;
        this.skill=skill;
    }
    PocketMonster(){}    //空构造


//    开始游戏  创建对象并PK
    public void begin(){
        System.out.println("请选择你的宠物属性：-一般\t格斗\t飞行\t毒\t地上\t岩石\t虫\n幽灵\t钢\t炎\t水\t草\t电\t超能\t龙\t恶\t妖精\t");
        Scanner pestb = new Scanner(System.in);
        String b= pestb.next();
        System.out.println("请选择你的技能属性：-一般\t格斗\t飞行\t毒\t地上\t岩石\t虫\n幽灵\t钢\t炎\t水\t草\t电\t超能\t龙\t恶\t妖精\t");
        Scanner pesta = new Scanner(System.in);
        String a= pesta.next();
        //创建宠物
        PocketMonster petsa = new PocketMonster(b,a);

//选择要攻击的宠物属性
        System.out.println("请选择敌对宠物的属性：-一般\t格斗\t飞行\t毒\t地上\t岩石\t虫\n幽灵\t钢\t炎\t水\t草\t电\t超能\t龙\t恶\t妖精\t");
        Scanner pestc = new Scanner(System.in);
        String c= pestc.next();

//        PocketMonster petsa = new PocketMonster("一般","一般");
        System.out.println(pk(petsa,c));

    }

    //打架方法
    public  static int pk(PocketMonster pest,String c){
        //普通
        if (pest.skill.equals(COMMNOLY)){
            if (c.equals(GHOST)){
                return ZERO;
            }else if (c.equals(ROCK)){
                return  HALF;
            }else
//                if (c.equals(COMMNOLY)||c.equals(COMBAT)||c.equals(FLIGHT)||c.equals(POISON)||
//                    c.equals(EARTH)||c.equals(INSECT)||c.equals(FIRE)||c.equals(WATER)||c.equals(GRASS)
//                    ||c.equals(ELECTRIC)||c.equals(SUPER)||c.equals(LOONG)||c.equals(EVIL)||c.equals(GOBLIN)
//                    ||c.equals(ICE))
// 以上  普通倍数判断  直接省略
            {
                return DOUBLE;
            }
        }
        //格斗
        else if (pest.skill.equals(COMBAT)){
            if (c.equals(GHOST)){
                return ZERO;
            }else if (c.equals(FLIGHT)||c.equals(POISON)||c.equals(INSECT)||c.equals(GOBLIN)||c.equals(SUPER))
            {
                return HALF;
            }else if (c.equals(COMMNOLY)||c.equals(ROCK)||c.equals(STEEL)||c.equals(ICE)||c.equals(EVIL)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //飞行
        else if (pest.skill.equals(FLIGHT)){
            if (c.equals(ROCK)||c.equals(STEEL)||c.equals(ELECTRIC)){
                return HALF;
            }else if (c.equals(COMBAT)||c.equals(INSECT)||c.equals(GRASS)||c.equals(GOBLIN)){
                return TWOFOLD;
            }else {
                return  DOUBLE;           }
        }
        //毒
        else if (pest.skill.equals(POISON)){
            if (c.equals(STEEL)){
                return ZERO;
            }else if (c.equals(POISON)||c.equals(EARTH)||c.equals(ROCK)||c.equals(GHOST)){
                return HALF;
            }else if (c.equals(GRASS)||c.equals(GOBLIN)){
                return TWOFOLD;
            }
        }
        //地上
        else if (pest.skill.equals(EARTH)){
            if (c.equals(FLIGHT)){
                return ZERO;
            }
            else if (c.equals(INSECT)||c.equals(GRASS)){
                return HALF;
            }else if (c.equals(POISON)||c.equals(ROCK)||c.equals(STEEL)||c.equals(ELECTRIC)||c.equals(FIRE)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //岩石
        else if (pest.skill.equals(ROCK)){
            if (c.equals(COMBAT)||c.equals(EARTH)||c.equals(STEEL)){
                return HALF;
            }else if (c.equals(FLIGHT)||c.equals(INSECT)||c.equals(FIRE)||c.equals(ICE)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //虫
        else if (pest.skill.equals(INSECT)){
            if (c.equals(COMBAT)||c.equals(FLIGHT)||c.equals(POISON)||c.equals(GOBLIN)||c.equals(GHOST)||c.equals(STEEL)||c.equals(FIRE)){
                return HALF;
            }else if (c.equals(GRASS)||c.equals(EVIL)||c.equals(SUPER)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //幽灵
        else if (pest.skill.equals(GHOST)){
            if (c.equals(COMMNOLY)){
                return ZERO;
            }
            else if (c.equals(EVIL)){
                return HALF;
            }else if (c.equals(GHOST)||c.equals(SUPER)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //钢
        else if (pest.skill.equals(STEEL)){
            if (c.equals(STEEL)||c.equals(FIRE)||c.equals(WATER)||c.equals(ELECTRIC)){
                return HALF;
            }else if (c.equals(ROCK)||c.equals(ICE)||c.equals(GOBLIN)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //炎
        else if (pest.skill.equals(FIRE)){
            if (c.equals(ROCK)||c.equals(FIRE)||c.equals(WATER)||c.equals(LOONG)){
                return HALF;
            }else if (c.equals(INSECT)||c.equals(STEEL)||c.equals(GRASS)||c.equals(ICE)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //水
        else if (pest.skill.equals(WATER)){
            if (c.equals(WATER)||c.equals(GRASS)||c.equals(LOONG)){
                return HALF;
            }else if (c.equals(EARTH)||c.equals(ROCK)||c.equals(FIRE)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //草
        else if (pest.skill.equals(GRASS)){
            if (c.equals(FLIGHT)||c.equals(POISON)||c.equals(INSECT)||c.equals(STEEL)||c.equals(FIRE)||c.equals(GRASS)||c.equals(LOONG)){
                return HALF;
            }else if (c.equals(ROCK)||c.equals(EARTH)||c.equals(WATER)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //电
        else if (pest.skill.equals(ELECTRIC)){
            if (c.equals(EARTH)){
                return ZERO;
            }
            else if (c.equals(ELECTRIC)||c.equals(GRASS)||c.equals(LOONG)){
                return HALF;
            }else if (c.equals(FLIGHT)||c.equals(WATER)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //超能
        else if (pest.skill.equals(SUPER)){
            if (c.equals(EVIL)){
                return ZERO;
            }
            else if (c.equals(SUPER)||c.equals(STEEL)){
                return HALF;
            }else if (c.equals(COMBAT)||c.equals(POISON)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //冰
        else if (pest.skill.equals(ICE)){
            if (c.equals(ICE)||c.equals(STEEL)||c.equals(FIRE)||c.equals(WATER)){
                return HALF;
            }else if (c.equals(LOONG)||c.equals(FLIGHT)||c.equals(EARTH)||c.equals(GRASS)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //龙
        else if (pest.skill.equals(LOONG)){
            if (c.equals(GOBLIN)){
                return ZERO;
            }
            else if (c.equals(STEEL)){
                return HALF;
            }else if (c.equals(LOONG)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //恶
        else if (pest.skill.equals(EVIL)){
            if (c.equals(COMBAT)||c.equals(EVIL)||c.equals(GOBLIN)){
                return HALF;
            }else if (c.equals(GHOST)||c.equals(SUPER)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        //妖精
        else if (pest.skill.equals(GOBLIN)){
            if (c.equals(POISON)||c.equals(STEEL)||c.equals(FIRE)){
                return HALF;
            }else if (c.equals(COMBAT)||c.equals(LOONG)||c.equals(EVIL)){
                return TWOFOLD;
            }else {
                return DOUBLE;
            }
        }
        return 0;
    }
    //主函数  通过空对象开始
    public static void main(String[] args) {
        PocketMonster Start = new PocketMonster();
        Start.begin();
    }
}

5.2 白盒测试 Junit 单元测试

用于测试代码逻辑是否有错误
鼠标右键点击 JunitTestcase
TestCase

package com.openlab.testone;
import org.junit.Test;
import com.openlab.test.PocketMonster ;
import junit.framework.TestCase;
public class PetTest {
	//@Test 测试注解
	@Test
	public void checkTypeToHurtTest1() {		
		PocketMonster p= new PocketMonster();
		int bRet = p.pk("一般", "幽灵系");
		// bRet  ---实际值
		// 设计书中的0 Pet.ZERO    ---期望值
		TestCase.assertEquals(Pet.ZERO, bRet);		
	}
	@Test
	public void checkTypeToHurtTest2() {	
		PocketMonster p= new PocketMonster();
		int bRet = p.pk("一般", "岩石系");
		// bRet  ---实际值
		// 设计书中的0 Pet.ZERO    ---期望值
		TestCase.assertEquals(Pet.HALF, bRet);		
	}
}

5.3 Switch语句

注意：
在等值判断的情况下会经常使用switch语句
浮点类型的数据不适合做等值判断，原因是判断的条件难以精确

package com.openlab.test;

import java.util.Scanner;

/*
 * 
 * 红绿灯  index 单词 索引 -----
 */
public class SwtichTest {
	public static void main(String[] args) {
		System.out.println("该亮哪个灯了？");
		Scanner input = new Scanner(System.in);
		String key = input.next();
		// charAt(index) 
		char c = key.charAt(0);
          switch (c) {
		case 'r':
			System.out.println("红灯");		
		case 'y':
			System.out.println("黄灯");		
		case 'g':
			System.out.println("绿灯");
			break;
		default:
			break;
		}
	}
}

一般范围性的判断使用if语句如果是等值类型的判断使用哪个都可以。

5.4 循环 while结构

5.5 循环 do-while 结构

int i = 0;
		
		do{
			System.out.println(i);
			i++;
		}while(i<10);

面试题： while循环和do-while循环的区别？

do-while要先执行一次循环体，再进行条件判断是否循环。而while是符合判断条件再执行。

5.6 for循环

5.7 break 和continue

break用于跳出循环
continue用于继续循环

重点总结

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

全部频道

JAVASE：基础语法总结