基础语法学习

注释

  1. 单行注释 //注释

  2. 多行注释 /* 注释 */

  3. JavaDoc:文档注释 /** */

    ​ /**

    ​ *@Description 内容

    ​ *@一些注释

    ​ */

标识符和关键字

  1. 关键字233

  2. 所有标识符都应该以字母(A-Z 或者 a-z),美元符(＄)、或者下划线(_)开始；不能使用关键字作为变量名或方法名，同时标识符是大小写敏感的

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

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

  3. 可以使用中文命名，但一般不建议使用(较low)

数据类型

基本类型

  1. 整数类型：

    ​ byte、short、int、long

    ​ 在定义long类型时，一般在数字后面加上L表示：long name = 23L;

  2. 浮点类型：

    ​ float、double

    ​ 在定义float类型时，一般在数字后面加上F表示：float name = 23F;

    ​

  3. 字符类型：

    ​ char (char name = 'A' 只能定义一个字符，'AB'不行)

    ​ // 字符串：String 不是关键字，是一个类 (String name = "CBDA"😉

  4. boolean类型：(是非)

    ​ true、false (boolean name = true)

类型拓展

  1. 整数拓展：二进制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);

//输出结果：10 8 16

  2. 浮点数拓展：银行业务怎么表示钱？

    //BigDecimal 数学工具类(大数类型，以后会说)

//float 能表现的字长是有限的  离散的 存在舍入误差  结果只能是 大约数   接近但不等于
//double

//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较
//最好完全避免使用浮点数进行比较

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

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

//输出结果：false true

  3. 字符拓展：

    char c1 = 'a';
char c2 = '中';

System.out.println(c1);

System.out.println((int)c1);    //强制转换

System.out.println(c2);

System.out.println((int)c2);    //强制转换

//输出结果：a 97 中 20013

//所有的字符本质还是数字
//编码  unicode 编码表：(97 = a    65 = A)  占2字节 最多可表示0~65536个字符   2^16 = 65536
//  U0000 - UFFFF

char c3 = '\u0061'; //斜杠u代表转义
System.out.println(c3); //a

//输出结果：a

  4. 转义字符：

    //转义字符
//  \t  制表符
//  \n  换行
//等一系列，可自行查询

System.out.println("Hello\tWorld!");

System.out.println("Hello\nWorld!");

//输出结果：Hello	World!		Hello
//						   	   World!

  5. 布尔值拓展：

    boolean flag = true;

//都默认判断括号里是否为真
if (flag==true){}   //新手常用
if (flag){}   //老手常用

//Less is More! 代码要精简易读

  6. 未学到的零散拓展 (增加兴趣)

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

//输出结果：false true

//等之后学到对象   从内存分析

类型转换

低-----------------------------------------------------------------高

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

(小数优先级大于整数，float是32、long是64，所以float优先级高)

  1. 强制类型转换：

    //强制转换  (类型)变量名   高-->低

int i = 128;
byte b = (byte)i;   //内存溢出	(byte 最大127)

System.out.println(i);
System.out.println(b);

//输出结果：128  -128

char c = 'a';
int d = c+1;

System.out.println(d);
System.out.println((char)d);

//输出结果：98 b

  2. 自动类型转换：

    //自动转换   低-->高

int i1 =128;
double d = i1;

System.out.println(i1);
System.out.println(d);

//输出结果：128  128.0

  3. 注意点：

    1. 不能对布尔值进行转换
    
2. 不能把对象类型转换为不相干的类型
    
3. 在把高容量转换为低容量的时候，强制转换
    
4. 转换的时候可能存在内存溢出，或者精度问题！(精度问题一般会在小数用到)

  4. 精度问题：（接上方注意点4）

    //转换后小数没了

System.out.println((int)23.7);  //23
System.out.println((int)-45.89f);   //-45

//输出结果：23   -45

  5. 溢出问题

    //操作比较大的数时，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割

int money = 10_0000_0000;	//下划线不会被输出，适合用来计数
int years = 20;
int total = money * years;  //-1474836480 , 计算的时候溢出了
long total2 = money * years;

System.out.println(total);

//输出结果：-1474836480

System.out.println(total2); //默认money和years是int ， 计算完之后才转换成long类型 ， 转换之前已经存在问题了

//输出结果：-1474836480

long total3 = money * ((long)years);    //在做这个操作时，他会把整个表达式提升，就会全部用long进行计算

System.out.println(total3);

//输出结果：20000000000

//  L   l   尽量都用大写字母表示防止混乱 (L是指加在数字后面的：10_0000_0000L 表示long类型)

变量、常量、作用域

​ type varName [=value] [{,varName[=value]}] ;

//数据类型 变量名 = 值; 可以使用逗号隔开来声明多个同类型变量。

//例子
int a=1,b=2,c=3;  //程序可读性 差，一般不建议使用
String name = "hetui!";
char x = 'X';
double pi = 3.14;

  1. 变量作用域：类变量、实例变量、局部变量

    public class Variable{
    static int allClicks=0;	//类变量
    String str="hello world";	//实例变量
    
    public void method(){
        int i =0;	//局部变量
    }
}

    public class Demo4 {

    //类变量   static (静态) 之后学到内存分析jvm的时候再重点学习static
    //目前，先把方法和类变量前都加上static，方便调用它，就不用去new了，new在对象时候学
    static double salary = 2500;

    //属性：变量

    //实例变量：从属于对象; 如果不自行初始化，这个类型的默认值 整数:0 小数:0.0 字符串:u0000  (方法外,类里面)
    //布尔值:默认是false
    //除了基本类型,其余的默认值都是null;
    String name;
    int age;


    //main方法
    public static void main(String[] args) {
        
        //局部变量：必须声明和初始化值
        int i;
        System.out.println(i);
        //输出报错：可能尚未初始化变量
        int i1 = 10;
        System.out.println(i1);
        //可正常输出
        


        //变量类型  变量名字 = new Demo4();
            Demo4 demo4 = new Demo4();
        System.out.println(demo4.age);
        System.out.println(demo4.name);
        //输出结果：0	null

        //类变量   static (静态) (这里可以直接调用，不需要像上面一样new)
        System.out.println(salary);


    }

    //其他方法
    public void add(){

    }

}

  2. 常量：初始化后不能再改变的值

    常量名一般使用大写字符

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

    public class Demo5 {

    //修饰符，不存在先后顺序   (static final 修饰double)
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
        
        //输出结果：3.14
    }
}

  3. 变量的命名规范：

    1. 所有变量、方法、类名：见名知意
    2. 类成员变量、局部变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastName
    3. 常量：大写字母和下划线：MAX_VALUE (一般用大写，如果单词较多，中间加下划线去定义)
    4. 类名：首字母大写和驼峰原则：Man , GoodMan (新建class的名字)
    5. 方法名：首字母小写和驼峰原则：run() , runRun()

基本运算符

算术运算符：+，-，*，/，%，++，--

赋值运算符：=

关系运算符：>，<，>=，<=，==，!=，instanceof

逻辑运算符：&&，||，! (与或非)

(以下了解即可)

位运算符：&，|，^，~，>>，<<，>>>

条件运算符：?

扩展赋值运算符：+=，-=，*=，/=

演示

//  二元运算符

int a = 10;
int b = 20;
int c = 25;
int d = 25;

System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);

System.out.println(a/b);    //a,b都为int型,除完也为int型,四舍五入取0,因为只有整数部分
System.out.println(a/(double)b);    //强转一下，转一个为double
//输出结果：0 0.5

long a = 23333333333333L;
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   (包括short + byte 结果也为int)
System.out.println((String)(c+d));    //在转为String时,系统报错：cannot cast 'int' to 'java.lang.String' (所以为int类型)

//关系运算符返回的结果：   正确，错误  布尔值

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

//取余(模运算)
System.out.println(c%a);    //c / a     21 / 10 = 2 ... 1
//输出结果：1

System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
//输出结果：false，true，false，true

自增自减运算符、初识Math类

//++    --    自增、自减    一元运算符

int a = 3;

int b = a++;    //执行完这行代码后，先给b赋值，再自增
//a++   a = a + 1

System.out.println(a);

//++a   a = a + 1
int c = ++a;    //执行完这行代码前，先自增，再给c赋值

System.out.println(a);
System.out.println(b);
System.out.println(c);

//输出结果：4 5 3 5

//幂运算 2^3   2*2*2 = 8   很多运算，我们会使用一些工具类来操作

double pow = Math.pow(2, 3);
System.out.println(pow);
//输出结果：8.0

逻辑运算符、位运算符

  1. 逻辑运算
//逻辑运算符

// 与(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));   //如果是真，则为假；如果是假，则为真
//输出结果：false true true


//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);   //这行代码执行到c<4(为假,已经出结果了)就不继续往下执行了
System.out.println(d);
System.out.println(c);   //如果执行了c++，那么结果应当是c = 6，但没有执行，所以这叫短路
//输出结果：false 5
  1. 位运算
//位运算

/*
//二进制
A = 0011 1100
B = 0000 1101
-----------------------------------------------------------
A&B = 0000 1100   //A与B，上下比较如果两个都为1则为1，否则都为0
A|B = 0011 1101   //A或B，上下比较如果两个都为0则为0，否则都为1
A^B = 0011 0001   //A异或B，上下比较如果两个相同则为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

*/

System.out.println(2<<3);
//输出结果：16

三元运算符及小节

  1. 扩展赋值运算符

    int a = 10;
int b = 20;

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

System.out.println(a);


//字符串连接符    在 + 两侧他只要有一方出现了 String 类型他就会把其他操作数都转换成 String 再进行连接

System.out.println(""+a+b);    //如果字符串在前面，后面的会拼接
//输出结果：1020
System.out.println(a+b+"");    //如果字符串在后面，前面的会进行运算
//输出结果：30

  2. 条件运算符(三元运算符)

    // x ? y : z
//如果x==true，则结果为y，否则为z

int score = 50;
String type = score <60 ?"不及格":"及格";

System.out.println(type);
//输出结果：不及格

包机制

一般利用公司域名倒置作为包名：com.example.www

//包语句的语法格式为：
package pkg1[. pkg2[. pkg3…]];

//为了能够使用某一个包的成员，我们需要在java程序中明确导入该包，使用“import”语句可完成此功能
import package1[.package2…].(classname|*);

举例：

package com.cnblogs.operator;

import com.cnblogs.base.*;	//导入这个包下所有的类，*代表所有类

//下面代码可不用看

public class Demo8 {
    public static void main(String[] args) {
        
    }
}

JavaDoc

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

举例：

package com.cnblogs.base;

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


//jdk帮助文档：https://docs.oracle.com/javase/8/docs/api/
public class Doc {

    String name;    //类变量(在类里定义一个变量)

    /**
     * @author H921
     * @param name
     * @return
     * @throws Exception
     */

    //定义一个方法(之后讲方法的时候会明白这些是如何定义的)
    public String test(String name) throws Exception{
        return name;
    }

    //除了通过命令行生成   javadoc   参数  java文件
    //需学会查找使用IDEA生成javadoc文档！   面向百度编程！(不会的东西，第一时间问百度)
    //基础部分的一切知识，后面几乎每天都会用
    
}

  1. 找到类的地址（右键类，点Show in Explorer）

  2. 在当前文件夹打开命令行（导航栏前面 空格 + cmd）

  3. 输入：javadoc -encoding UTF-8 -charset UTF-8 Doc.java (这是防止有中文命名出现乱码情况)

    ​ 编码为：UTF-8 字符及编码：UTF-8

  4. 会生成 index.html（首页），可点击打开文档

posted @ 2021-02-04 18:32  H921  阅读(24)  评论(0)    收藏  举报