Java基础语法

呆小嘪

已于 2022-10-23 11:47:34 修改

阅读量118

点赞数

分类专栏： java学习之路文章标签： java

于 2022-10-21 17:26:43 首次发布

本文链接：https://blog.csdn.net/marhap/article/details/127450561

版权

java学习之路专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java基础

标识符

关键词

关键词	作用	结构
abstract	会使这个类成为一个抽象类	abstract class E{} / public abstract void Xxx()
case	在Switch中使用。匹配一个具体的值	switch(name){case “XXX” break;}
continue	跳过循环体中剩余的语句而强制执行下一次循环，	for (int i = 0; i < numbers.length; i++) {if (i == 3) {continue;}}
enum	枚举是一个特殊的类,各个常量使用逗号 , 来分割。	enum Color { 常量, 常量, 常量; }
for	是一种在程序执行前就要先判断条件表达式是否为真的循环语句	for(条件表达式1;条件表达式2;条件表达式3) { 语句块; }
instanceof	判断前面的对象是否属于后面的类，或者属于其子类(什么什么…是否是…什么什么)；如果是，返回 true，不是返回 false；	引用类型变量(object) instanceof 类(class)
new	Java中创建一个对象	Object obj = new Object();
return	1.返回方法指定类型值 2.用于方法结束的标志,return 后面的语句不会被执行	return XXX;
switch	可以实现根据某一变量选则执行代码块	switch (a){ case 0: break; case 10: break;
transient	用来表示一个成员变量不是该对象序列化的一部分	private transient String name;
assert	可以看做是程序语言关于异常处理的一种高级方式	assert <boolean表达式>
catch	异常处理	try{ 可能出现的代码;} catch(异常类名1){处理异常；}
default	修饰符	default public void method()
extends	让一个类和另一个类建立起一种父子关系	子类 extends父类
goto	跳出循环嵌套
int	整数类型	int i = 10;
package	包机制	package pkg1[.pkg2[.pkg3…]];
strictfp	浮点类型做精确运算的一个关键字	public strictfp class Test {}
synchronized	作用于当前实例/类对象加锁，进入同步代码前要获得当前实例/类对象的锁	public synchronized void increase(){}
try	用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。	try{ 可能出现的代码;} catch(异常类名1){处理异常；}
boolean	布尔值	boolean flog = true; // boolean flog = false;
char	字符类型	char c = ‘A’;
do	do-while循环，先执行一次，然后在判断	do{}while(){};
final	表示变量的值不可改变，此时该变量可被称为常量。	public static final String NAME = “张三”;
if	属于选择结构，if语句又被称为分支语句/条件控制语句：	if(条件){…}else{…}
interface	接口(interface)是抽象方法和常量值定义的集合	public interface Runner {}
private	被private关键字修饰的内容只能在本类中使用,其他类中无法使用	private String name;
short	整数类型	short s = 1 ;
this	指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）	this.name = name;
void	指示此方法未返回任何类型的值。	public void Num(){}
break	用于完全结束一个循环，跳出循环体。
class	`Class`是一个位于`java.lang`包下面的一个类，在`Java`中每个类实例都有对应的`Class`对象。类对象是由Java虚拟机(JVM)自动构造的。	public class ToStringTest{}
double	浮点数类型（小数）	double d = 1.0 ;
finally	finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生	try{}catch(Exception e){}finally{ }
implements	用来实现接口中定义的抽象方法	public class XxXx implements Xxx{}
long	整数类型	long l = 10L ;
protected	protected 修饰的类和属性,对于本类、本包及其子类可见。	protected void SOUT(){}
static	用static声明的成员变量为静态成员变量，也成为类变量	private static String name;
throw	如果一个方法可以引发异常，而它本身并不对该异常处理，那么它必须将这个异常抛给调用它的方法；
volatile	Volatile是Java虚拟机提供的`轻量级`的同步机制
byte	整数类型	byte b = 1;
const	可以对其进行静态数据类型检查
else	如果if语句中条件为false，则else语句指定要执行的Java代码块。	if(条件){…}else{…}
float	浮点数类型	float f = 2.1F;
import	import关键字是用来导入包的	Java.(包名).(方法名).(包中的类名)；
native	native方法是java与其他语言协作的时候使用的	public native int hashCode();
public	表示可以被该项目的所有包中的所有类访问	public class IceCream{}
super	super表示超类（就是我们俗称的父类），当子类需要引用父类的字段时，我们就可以使用super.
throws	作用是声明抛出
while	循环结构:先判断循环条件，再执行循环操作语句。	while(条件) {}

java中的各种名

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

类名

public class HelloWorld{
    // HelloWorld --> 类名
}

方法名

public void init(){
    // init --> 方法名
}

变量名

int num = 10;              // num --> 变量名
String teacher = "张三";   // teacher --> 变量名
boolean flag = true;      // flag --> 变量名

数据类型

基本类型（八个）
引用类型

八大基本数据类型

整数

int i = 10;
byte b = 20;
short s = 30;
long l = 30L; //Long 类型要在数字后面加个L

浮点数：小数

float f = 50.1F;//Lfloat类型要在数字后面加个L
double d = 3.14159;

字符

char c = ‘A’;//只能输入一个字 如： ‘你’

布尔值：是否

boolean flog = true;
// boolean flog = false;

引用类型

接口
类
数组

字符串

String s = “你好世界”;

拓展

整数拓展

二进制0b
八进制0
十进制
十六进制0x

int i = 10;
int i2 = 010; //八进制0
int i3 = 0x10 //十六进制0x

类型转换

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

强制转换（类型）变量名高 —> 低
自动转换低 —> 高

int i = 16;
byte b = (byte)i;
double d = i;

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或者精度问题！

char c = ‘a’;
int i = a+1;//98

char d = (char)i; // b

int money = 10_0000_0000;// 输出依然是 1000000000
int years = 20;
int total = money * years; // -1474836480 计算的时候溢处
long total2 = money * years //默认是int，转换之前已经存在问题了

//解决之法
long total3 = money * ((long)years); // 先把一个数据转换为long；

变量

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

//数据类型  变量名  =  值
   String str = “我是爱学习的人”；

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

int a,b,c;// 不推荐这样写，代码可读性太差
char x = ‘X’;
double pi = 3.14;

变量作用域

类变量
实例变量
局部变量

public class Test
    
    // 类变量  static
    static String name = “张三”；
    
    // 实例变量：从属于对象，如果不自行初始化，这个类型就会赋 默认值
    // 类型默认值： int->0，double->0.0, boolean->false
    //除了基本类型，其余的默认值都是null；
    int i;
    Sring s;
    
    //main方法
    public static void main(Sring[] args){
        
        //局部变量：必须声明和初始化
        int a = 10;
        System.out.println(a); // 10;
        
        // 实例变量：
        // 变量类型  变量名字 = new Test;
        Test test = new Test;
        System.out.println(test.i); // 0
        System.out.println(test.s); // null
        
        // 类变量   static
        System.out.println(name); //张三
    }
    
    //其他变量
    public void add(){
    
    }

常量

常量：初始化后不能再改变值！不会变动的值。

final 常量名 = 值；
final double PI = 3.14;

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

public class Test{

    //修饰符，不存在先后顺序
    //static final double PI = 3.14; //都可以
    final static double PI = 3.14;

    public static void main(String[] args){
        System.out.println(PI);
    }
}

变量的命名规范

所有的变量、方法、类名：见名知意
类成变量：首字母小写和驼峰原则 —-> lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线 —-> MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMart
方法名：首字母小写和驼峰原则：run(),runRun()

运算符

算术运算符：+，-，*，/，%，++，–
赋值运算符：=
关系运算符：>，<，>=，<=，==，!=instanceof
逻辑运算符：&&，||，！
位运算符：&，|，^，~，>>，<<，>>>(了解！！！)
条件运算符：？：
扩展赋值运算符：+=，-=，*=，/=

int a = 3;

int b  = a++; //执行完这行代码后，先给b赋值，再自增
//a = a +1;
System.out.println(a); // 4
System.out.println(b); // 3

// a = a + 1;
int c = ++a; // 执行完这行代码前，先自增，再给c赋值
System.out.println(a); // 5
System.out.println(c); // 5

// 短路运算
int c = 5;
boolean d = (c < 4) && (c++ < 4); // 因为（c < 4)为假 所以c++没执行。
System.out.println(d); // false
System.out.println(c); // 5

/*
	A = 0011 1100
	B = 0000 1101
	--------------------
  A&B = 0000 1100
  A|B = 0011 1101
  A^B = 0011 0001
   ~B = 1111 0010
   ---------------------
   2*8 = 16  2*2*2*2
   <<  ---->  *2
   >>  ---->  /2
   
   0000 0000  -> 0
   0000 0001  -> 1
   0000 0010  -> 2
   0000 0100  -> 4
   0000 1000  -> 8
   0001 0000  -> 16
   
   */

System.out.println(2<<3); // 8

int a = 10;
int b = 20;

a+=b;  // a = a + b;  
a-=b;  // a = a - b;

int a = 10;
int b = 20;

// 字符串在前面 后面的也会转换成字符串，不会相加
System.out.println("" + a + b);   // 1020

// 字符串在后面，前面的会相加，不会转换为字符串
System.out.println(a + b + "");  //30

// x ? Y : Z
// 如果x==true，则结果为Y，否则结果为Z

int score = 80;
String type = score < 60 ? "不及格":"及格";
System.out.println(type); // true

包机制

包语句的语法格式为：

package pkg1[. pkg2[pkg3…]]

一般利用公司域名倒置作为包名；

com.mardan.xxx

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

import package1[.package2…].(classname|*);

JavaDoc

javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

package com.mardan;

/**
 * @author mardan
 * @version 1.0
 * @since 1.8
 */

public class Doc {
    String name = null;
    
    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    
    public String init(String name) throws  Exception{
        return name;
    }
}