java基础语法

CX330丶w

于 2021-02-03 18:48:04 发布

阅读量90

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/qq_51243773/article/details/113617367

版权

笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

java基础语法学习

注释

// 单行注释

/* 多行注释 */

/** 文档注释 */

标识符

关键字

1	2	3	4	5
asbtract	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所有的组成部分都需要名字，类名，变量名以及方法名都称为标识符。

所有的标识符都应该以字母，美元符，或者下划线开头；

首字母之后可以是字母，美元符，下划线或数字的任意字符组合；

不能使用关键字作为变量名或方法名；

标识符是大小写敏感的

可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，显得很low

数据类型

基本类型

整数类型：byte，int，short，long

浮点类型：float，double

布尔类型（boolean）：占1位其值只有true和false

字符类型：char

public class demo01 {
    public static void main(String[] args) {
        byte num1 = 10;
        short num2 = 128;
        int num3 = 1000000;
        long num4 = 100000L;    //长整型后加L
        float num5 = 1.23F;     //float后加F表示float型变量
        double num6 = 3.14159265358;
        boolean flag = true;
        char flag1  = '中';
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
        System.out.println(num5);
        System.out.println(num6);
    }
}

import javax.swing.*;

public class demo02 {
    public static void main(String[] args) {
        //整数扩展      进制      二进制0b       十进制     八进制0        十六进制0x
        int i = 10;
        int i1 = 010; //八进制
        int i2 = 0x10; //十六进制0x     0-9 A-F 16
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println("==============================================");
        //=====================================================
        //浮点拓展  银行业务怎么表示                       =========
        //BigDecimal 数学工具类                         =========
        //=====================================================

        //float 有限  离散  舍入误差    大约  接近但不等于
        //double

        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);

        float d1 = 212113443432f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);

        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);

        //所有字符的本质还是数字
        //编码

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

        //转义字符

        System.out.println("Hello\nWorld");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);
        String sc = ("hello world");
        String sd = ("hello world");
        System.out.println(sc==sd);

    }
}

引用类型

类，接口，数组

类型转换

低---------------------------------------------->高

byte，short，char->int->long->float->double

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

强制类型转换

自动类型转换

public class demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b =(byte)i; //内存溢出
        // 强制转换（类型） 高----低
        //自动转换  低---高
        System.out.println(i);
        System.out.println(b);
        /*
        注意点：
        1.不能对布尔进行转换
        2,不能把对象类型转换为不相干的类型
        3，再把高容量转换为低容量的时候，强制转换
        4，转换的时候可能存在内存溢出，或者精度问题
        */
        System.out.println("=======================");
        System.out.println((int)23.7);//23
        System.out.println((int)-24.35);//-24

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

public class demo04 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //jdk7新特性，数字之间可以用下划线隔开
        int money = 10_0000_0000;
        int years = 20;
        int total =money * years; //-14.....,计算的时候溢出了
        long total2 = money*years; //默认是int，转换之前已经存在问题了
        long total3 = money*((long)years); //正常输出
        System.out.println(total3);
    }
}

变量

数据类型变量名 = 值

public class demo05 {
    //类变量 static
    static double salary = 2500;
    //属性: 变量
    //实例变量：从属于对象，如果不初始化，默认值为0 0.0
    //布尔值：默认false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量，必须先声明和初始化
        int i = 10;
        System.out.println(i);

        //变量类型  变量名=new demo5()
        demo05 Demo05 =new demo05();
        System.out.println(Demo05.age);
        System.out.println(Demo05.name);
        System.out.println(salary);
    }
}

常量

final 数据类型 = 值

public class demo06 {
    static final double PI = 3.14; //static修饰符，不存在先后顺序

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

}

变量的命名规范

所有变量，方法，类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部成员：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()

运算符

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

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //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/(double)b);
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 12368266462874L;
        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
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  布尔值
        //if

        int a = 10;
        int b = 20;
        int c = 30;

        //取余，模运算
        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 demo4 {
    public static void main(String[] args) {
        //++ --     自增，自减   一元运算符
        int a = 3;
        int b = a++;    //执行完这行代码后，先给b赋值，再自增
        //a = a + 1
        System.out.println(a); //a = 4
        //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);
        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:"+(b&&a));   //逻辑与运算：两个变量都为真，结果才为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); //因为c<4，已经为假，所以后面的c++<4没有执行
        System.out.println(d);
        System.out.println(c);
    }
}

位运算

package operator;

public class Demo6 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        ---------------
       与运算 A&B = 0000 1100 同1则1，同0为0，不同为0
       或运算 A|B = 0011 1101 同1为1，同0为0，不同为1
       异或运算 A^B = 0011 0001 同1为0，同0为0，不同为1
       非运算 ~B = 1111 0010 取反
        
        2*8 =16 2*2*2*2
        使用位运算效率极高！！！
        <<  左移*2
        >>  右移/2
        
        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
        * */
    }
}

扩展赋值运算符

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+"");
        /*这两种写法是不一样的，第一行它会输出1020，把两个数值连接一起；
        第二行它会先执行a+b，所以结果事30
         */
    }
}

三元运算符

package operator;

public class Demo8 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true，则结果为y，否则结果为z

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

包机制

一般包名使用倒置域名：com.baidu.www
使用import来导入包:import + 包名

Javadoc

javadoc命令是用来生成自己的API文档
参数信息
- @author 作者名
- @version 版本号
- since 指明需要最早使用的jdk版本
- @return 返回值情况
- @throws 异常抛出情况
javadoc -encoding UTF-8 -charset UTF-8 + 类-------中间的参数是为了解决字符编译的问题

package com.wxj.www.operator;
/**
 * @author wang
 * @version 1.0
 * @since 1.8
 */

public class Doc {
    String name;

    /**
     * @author wxj
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    
    //通过命令行 javadoc 参数 java文件
    //利用IDEA产生javaDoc文档


}