基础语法

第二天

配置IDEA环境

在空项目添加Model
选择java
选择项目结构配置java文件
选择代码输出文件

项目快捷键

psvm: public static void main(String[] args)

sout: System.out.println("hi world")

字节

位(bit) : 是计算机内部的最小单位
字节(byte): 是计算机中数据处理的基本单位,习惯用大写 B 表示
1B(byte,字节) = 8bit (位)

n进制,逢几进一

十进制:逢十进一

基数:进制中允许使用的数码个数

注释

结构一旦复杂，就需要注释
注释并不会被执行，是给我们写代码的人看的
书写注释是非常好的习惯

/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            佛祖保佑       永无BUG
*/

public class HelloWorld {
    public static void main(String[] args) {
        //输出一个hi，world
        //单行注释

        /*   我是
        多行注释
        注释，随便写
         */

        /**我是文档注释
         * @Description Helloworld
         * @Author
         */

        System.out.println("hi，world");
    }
}

标识符和关键字

 String Apple = "ios";
 String apple = "ios";
 String $apple = "ios";
 String _apple = "ios";
//标识符可以大小写,$,_,开头
//非法开头:数字,#,*,%

标识符是大小写敏感的
可以使用中文命名,但不建议
不能用关键字作为变量名或方法名

Java关键字:指向网站

数据类型

Less is More 代码要精简

强类型语言
- 要求变量严格符合规定，所有变量必须先定义才能使用
- 安全性高
- 效率比较低
弱类型语言
- 要求不那么严格
- 运行快

java数据类型分两大类

基础类型
- 数值类型
  - 整数类型
    1. byte占1个字节：-182 - 127
    2. short占2个字节：-32768 - 32767
    3. int占4个字节：-2147483648 -2147483647（21亿）
    4. long占8个字节：非常大
  - 浮点类型
    1. float占4个字节同int范围
    2. double占8个字节
  - 字符类型
    1. char占2个字节
- Boolean类型：占1位，只有true和false两个值
引用类型
- 类
- 接口
- 数组

public class Hello {
    public static void main(String[] args) {
        //整数拓展： 进制  二进制0b 十进制 八进制0 十六进制0x
        int i = 10;
        int i2 =0b100;
        int i3 =010;//八进制
        int i4 =0x10;//十六进制 0~9 A~F

        //浮点扩展 float double,有限的  离散  舍入误差  大约  接近但不等于
        float f = 0.1F;
        double d = 1.0/1;

        System.out.println(f==d);//结果为false

        float d1 = 23132323F;
        float d2 = d1+1;

        System.out.println(d1==d2);//结果为ture
        //不用浮点数进行数据运算
        
        //==============================================
         String a="hello";
        System.out.println(a);

        //整数
        int num1 =10; //int最常用
        byte num2 =127;
        short num3 =30;
        long num4 = 30L; //Long类型要在数字后面加个L

        //浮点数:小数
        float num5 =50.1F; //float类型要在数字后面加个F
        double num6 =3.141526535;

        //字符
        char name = '严'; //注意只能对应一个汉字,对应符为 '
        //字符串,String不是关键字,是类
        //String namea = "小严";
        
        //==============================================
        char c1 ='a';
        char c2 ='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        System.out.println(c2);
        System.out.println((int)c2);
        //所有的字符本质还是数字
        //编码 Unicode 2字节 65536 Excel 2的十六次方=65536
        //Unicode表  97=a 65=A

        char c3 ='\u2314';  // 转义字符（十六进制）
        System.out.println(c3);

       // \t 制表符号=tab  \n 换行
        System.out.println("Hello\tworild");

        System.out.println("Hello\nworld");
       
        // 布尔值的扩展
        boolean flag = ture;
        if (flag==ture){}//新手
        if (flag){}//老手
 
        
    }

类型转换

Java是强类型语言
运行中,不同类型数据转化为同一类型

public class dome01 {
    public static void main(String[] args) {
        int i=128;
        byte b = (byte)i;//内存溢出
        //强制转换  (类型)变量名  高-低
        //自动转换  低-高
        /*
        注意点:
        1. 不能进行布尔值的转换
        2. 不能把对象类型转换为不想干的类型
        3. 在高容量装转换到低容量,强制转换
        4. 转换的时候可能存在内存溢出,或者精度问题
        5. 先转换再运算
        6. JDK7新特性,数字之间可以用下划线分割
        7. L用大写的,小写l在代码中很像1
         */

        System.out.println(i);
        System.out.println(b);
       
        System.out.println((int)23.7);
        System.out.println((int)-46.789f);
       
        char c = 'a';
        int d = c+1;//原c定义a转换为U码再进行加一
        System.out.println(d);//输出为U码
        System.out.println((char) d);//强制转换
        
      //======================================================
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;
        System.out.println(total);//数据溢出-1474836480
        long total2 = money*years;//默认为int了,先进行int运算再转换
        long total3 = money*((long)years);//先把一个数转换为Long
        System.out.println(total3);



    }
}

变量,常量,作用域

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

//变量
public class dome01 {
    public static void main(String[] args) {
        
        int a=1,b=2,c=3;
        //尽量别这么定义，可读性差
        String name ="xiaoyan";
        char x ='x';
        double pai =3.14;
  
    }
}

//常量
public class dome01 {
    static final double PT = 3.14159;
    //修饰符不存在先后顺序
    //使用final命名大写
    
    public static void main(String[] args) {
        System.out.println(PT);

    }
}

//作用域
public class Doem01 {
    static int allClicks = 0;//类变量,static可直接引用
    String skr = "hello,world";//实例变量 
    
    public static void main(String[] args) {
        int i = 01;//局部变量
    
    }
}

//属性:变量
public class dome02 {    
    //实例变量:从属于对象
    String name;
    int age;
 
    //类变量 static
    static double salary=2500;

    public static void main(String[] args) {
         //类变量可以直接输出
        System.out.println(salary);
        
        //局部变量:必须声明和初始化值
        int a = 3
        System.out.println（a）；
            
        //变量类型 变量名字
        dome02 dome02 = new dome02();//定义一个dome02为dome02类
        System.out.println(dome02.age);//数值类型初始化都是0或0.0
        System.out.println(dome02.name);//除了基本类型其余都是null
        //布尔值:默认为false


    }
    //还有一个其他方法
    public void add(){

    }
}

命名规范

所有变量,方法,类名:见名知意
类成员变量,局部变量,方法名:首字母小写,和驼峰原则:nameLastAge
常量:大写字母和下划线:MAX_VALUE

运算符

算术运算符: + - * / % ++ --
赋值运算符: =
关系运算符: >, <, >=, <=, ==, !=, 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 = 42;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//无法正确计算结果,因为int值算出结果为int类直接省略小数
        System.out.println(a/(double)b);//可以输出正确结果
        System.out.println(d%a);//d取余a,d模运算a
        
        //=======================================
        long a = 1212121212L;
        int b = 128;
        short c = 10;
        byte d = 6;

        System.out.println(a+b+c+d);//有long类型转换为long类型
        System.out.println(b+c+d);//默认int
        System.out.println(c+d);//默认int
        System.out.println(d);//默认int
        //元素中有long默认long类型,没有即使是低位也默认int,小数double同理
        //检验方法:string低位相加结果 string无法标识int结果
        //System.out.println((String) (c+d));
        
        //=======================================  
        //++  -- 自增  自减  一元运算符
        int a = 3;

        int b = a++;//先执行代码给b赋值,再自增,a=a+1
        int c = ++a;//先给a自增,再给c赋值

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

        //幂运算: 2^3  2*2*2 =8,,很多运算需要工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
        
        //========================================
        //与 (and) 或(or) 非(取反)
        boolean a = true;
        boolean b =false;
        System.out.println("a && b："+(a&&b));//两个为真才为正,结果为true
        System.out.println("a||b:"+(a||b));//一个为真,结果为ture
        System.out.println("！（a && b）:"+!(a&&b));//如果是真则为假,如果为假则为真
       
         //短路:当一个项目已经能输出结果的时候则不会接着运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);
        //c<4错误短路则后面的c++自增不发生
        
        //========================================
        // x ? y:z 三元运算符
        //如果x为真,结果为y否则为z

        int score = 80;
        String type = score <60 ? "不及格":"及格";
        System.out.println(type);//输出及格
        
        //=========================================
          /* 
        位运算
        A = 0011 1100
        B = 0000 1101
        A&B 0000 1100 (交集,都为1则为1,否为0)
        A/B 0011 1101 (并集,有1则1)
        A^B 0011 0001 (取反,如果相同为零,不同为1)
        ~B 1111 0010 (取反1为0,0为1)
        
        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
        
         */
        
        //=========================================
        int a =10;
        int b =20;

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

        //字符串链接符 + ,string
        System.out.println("123"+a+b);//是字符连接串的效果输出为1231020
        System.out.println(a+ b+ "123");//前面是加法后面""内容为文本,输出为30123
       
    }
}

包机制

一般利用域名倒置做包名(com.baidu.www)
import 导入

javaDoc文档生成

生成自己的API文件

参数信息

@author 作者命
@version 版本号
@since 指名需要的最早使用的jdk版本
@param 返回值情况
@throws 异常抛出情况

package com.xiaoyan;
/**
 * @author kirret
 * @version 1.0
 * @since 1.8
 */
public class test {
    String name;

    /**//  输入/**会自动填充
     *
     * @param name
     * @return
     */
    public String Dome(String name){
        return name;

    }

}

生成javaDoc

命令行

中间的命令是为了编译中文以免乱码

Javadoc -encoding UTF-8 -charset UTF-8 文件命

IDEA

自定义范围

区域设置:zh_CN

其他命令行参数

-encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

自学说实在会有很多麻烦事，很多小细节都得靠查，而且很难描述，一查就要查好久
不过不都说，来自不易愈发珍惜
这样麻烦倒是记得深刻

posted @ 2021-02-09 23:47 kirret 阅读(98) 评论(0) 收藏举报

刷新页面返回顶部

kirret