day04_基础语法学习

最新推荐文章于 2024-08-12 16:47:32 发布

qq_46046706

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量65

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_46046706/article/details/113933809

版权

Java基础语法

一、注释

1. 单行注释

// 注释一行文字

2. 多行注释

可以注释一段文字

3. 文档注释

/**

二、标识符和关键字

1. 关键字

在这里插入图片描述

2. 注意：

所有的标识符都应该以字母（A-Z 或者 a-z），美元符（＄）、或者下划线 _ 开始
首字符之后可以是字母（A-Z 或者 a-z），美元符（＄）、或者下划线 _ 或任意数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、＄salary、_value、__1_value
非法标识符举例：123abc、-salary、#abc

public static void main(String[] args){
    String 王者荣耀 = "最强王者";		//“王者荣耀”是变量名
    System.out.println(王者荣耀);
}

可以使用中文命名，但是不建议使用，也不建议用拼音，很Low

dee

三、数据类型讲解

1. 强类型语言：

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
优点：安全性高、严谨缺点：速度慢

public static void main(String[] args){
    String a;		//这样定义是错误的，应该给a赋值
    System.out.println("a");
}

2. 弱类型语言：

VB、JS

3. 类型分两大类

基本类型（primitive type)
引用类型（reference type）

在这里插入图片描述

基本数据类型：

public class Demo02{
    public static void main(String[] args){
        //八大基本数据类型
        
        //整数
        int num1 = 10; //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L; //long类型要在数字后面加个L
        
        //小数
        float num5 = 50.1F;  //floa类型要在数字后面加F
        double num5 = 3.14159265358979323846456;
            
        //字符
        char name = '中';
        //字符串，String不是关键字，类
        //String name = “小深”;
        
        //布尔值：是与非
        boolean flag = true;
        //boolean flag = false;
        
    }
}

4. 字节

基本概念：
- 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制小数
- 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示
- 1B（byte，字节）= 8 bit（位）
- 字符：是指计算机中使用的字母、数字、字和符号
换算：
- 1bit表示1位
- 1Byte表示一个字节 1B = 8b
- 1024B = 1KB
- 1024KB =1M
- 1024M = 1G
- 1024G = 1TB

四、数据类型扩展及面试题讲解

1. 整数拓展：

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

public class Demo3{
    public static void main(String[] args){
    
        int i1 = 10;
        int i2 = 010;	//八进制
        int i3 = 0x10;  //十六进制0x  0~9 A~F 16
        
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        //10
        //8
        //16
    }
}

2. 浮点数拓展：

银行业务怎么表示￥？
float 有限、离散、舍入误差、大约、接近但不等于
double
最好完全使用浮点数进行比较

public class Demo3{
    public static void main(String[] args){
		
        float f = 01f;
        double d = 1.0/10;
        
        System.out.println(f==d);  //false
        
        float d1 = 23123123123123f;
        float d2 = d1 + 1;
        
        System.out.println(d1==d2);  //true
	}
}

3. 字符拓展：

所有字符本质是数字
编码 Unicode 2字节 0 - 65536
转义字符：\t 制表符
\n 换行

public class Demo3{
    public static void main(String[] args){
        char c1 = 'a';
        char c2 = '中';
        
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        
        System.out.println(c2);
        System.out.println((int)c1);//强制转换
    }
}

4. 布尔值拓展：

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

        boolean flag = true;
        
        if(flag==true){}  //新手
        if (flag){}  //老手
        
        //Less is More！ 代码要精简易读
        
    }
}

五、类型转换

1. 容量（字节大小）

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

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

2. 强制类型转换

避免 内存溢出 的问题
（类型）变量名高 --> 低

int i = 128;
byte b = (byte)i;

3. 自动类型转换

低 -----> 高

int i = 128;
double b = i;

4. 注意点

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

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


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

操作数比较大的时候，注意溢出问题 !

public class Demo() {
    public static void main(String[] args){
        //JDK7新特性，数字之间可以用下划线分割
        
        int money = 10_0000_0000;
        int years = 20;
        
        int total = money*years;//-1474836480,计算的时候已经溢出了
        
        long total2 = money*years; //默认是int，转换之前已经存在问题了
        
        long total3 = money*((long)years);  //先把一个数转换成long
        
        System.out.println(total);
        
    }
}

六、变量、作用域、常量

1. 变量

Java是强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
【注意】：

(1)每个变量都有类型，可以是基本类型，也可以是引用类型（String）

(2)变量名必须是合法的标识符

(3)变量声明是一条完整的语句，都以分号结束
变量的命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man, GoodMan
- 方法名：首字母小写和驼峰原则

2. 作用域

局部变量

public class Demo() {
    
    // 属性：变量
    
    // main方法
    public static void main(String[] args){
        
        // 局部变量：必须声明和初始化值,只在这里面有效
        int i = 10;
        
        System.out.println(i);
        
    }
    
    //其他方法
    public void add(){
        
    }
}

实例变量

public class Demo() {
    // 实例变量：从属于对象;
    // 如果不自行初始化，这个类型的默认值：0  0.0   0000
    // 布尔值默认是false
    // 除了基本类型，其他都是null
    
    String name;
    int age;
    
    public static void main(String[] args){
        
        // 变量类型  变量名 == new Demo();
        Demo demo = new Demo();
        System.out.println(demo.age);
        System.out.println(demo.name);
        
    }
}

类变量

public class Demo() {
	//类变量  static
    
    static double salary = 2500;
    
	public static void main(String[] args){
        
        System.out.println(salary);
        
	}
}

3. 常量

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

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

一般用大写字符

public class Demo() {
    
    static final double PI = 3.14;
    // final static double PI = 3.14;
    // final 是修饰符，不存在先后顺序
    
    public static void main(String[] args){
        System.out.println(PI);
    }
}

七、基本运算符

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

算术运算符

public class Demo01 {
    public static void mian(String[] args){
        
    // 二元运算符
    // Ctrl + D；复制当前行到下一行
    int a = 10;
    int b = 20;
    int c = 25;
    int d = 25;
    
    System.put.println(a+b);
    System.put.println(a-b);
    System.put.println(a*b);
    System.put.println(a/(double)b);	// 25
    }
    
}

转换运算

public class Demo02 {
    public static void mian(String[] args){
        long a = 123123123123213123L;
        int b = 123;
        short c = 10;
        byte d = 8;
        
        System.put.println(a+b+c+d);	// long
        System.put.println(b+c+d);		// int
        System.put.println(c+d);		// int
        // 如果有个数是long，则运算结果为long
        // 如果有个数是double，则运算结果为double
    }
}

关系运算符

public class Demo03 {
    public static void mian(String[] args){
        int a = 10;
        int b = 20;
        
        //取余：模运算
        System.put.println(c % a);
        
        System.put.println(a > b);
        System.put.println(a < b);
        System.put.println(a == b);
        System.put.println(a != b);
    }
}

自增、自减、Math类

public class Demo04 {
    public static void mian(String[] args){
        //++  --  自增，自减  一元运算符
        
        int a = 3;
        int b = a++;
        //a++   a = a + 1(执行完这行代码后，献给b赋值，再自增)
        
        int c = ++a;
        // 执行这行代码前，先自增，再给b赋值
        
        System.put.println(a);
        System.put.println(b);
        System.put.println(c);
        
        // 幂运算  2^3  2*2*2 = 8  很多运算，我们会使用一些工具类来操作
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

逻辑运算符

public class Demo05 {
    public static void mian(String[] args){
        // 与（and）  或（or）  非（取反）
        boolean a = true;
        boolean b = false;
        
        System.out.println("a && b" + (a && b) );
        //逻辑与运算：两个都为真，结果才为true
        System.out.println("a || b" + (a || b) );
        //逻辑或运算：两个都为假，结果才为false
        System.out.println("! (a && b) " +(a && b) );
        //如果是真，则变为假，如果是假则变为真
        
        //短路运算
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.orintln(d);
        System.out.orintln(c);
    }
}

位运算（效率极高！！）

public class Demo06 {
    public static void mian(String[] args){
        /*
        A = 0011 1100
        B = 0000 1101
        
        A&B = 0000 1100（只要有一个不为1，就是0）
 		A|B = 0011 1101 （只要有一个为1，就是1）
 		A^B = 0011 0001（相同：0，不相同1）
 		 ~B = 1111 0010 （取反：0-1）
 		 
 		 <<   *2
         >>   /2
        */
        
        System.out.println(2<<3);
    }
}

三元运算符

public class Demo07 {
    public static void mian(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);  //30
        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);
    }
}

八、包机制

包的本质就是文件夹

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

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

package com.kuang.operator;

import java.util.Date;
//import com.kuang.base.*;

九、JavaDoc生成文档

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

public class Doc{
    String name;
    
    /**
     *
     * @param name
     * return 
     */
    public String test(String name){
        return name;
    }
}

// javadoc -encoding UTF-8 -charset UTF-8 Doc.java

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

qq_46046706

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day04_基础语法学习

Java基础语法一、注释1. 单行注释// 注释一行文字2. 多行注释可以注释一段文字3. 文档注释/***/二、标识符和关键字1. 关键字2. 注意：所有的标识符都应该以字母（A-Z 或者 a-z），美元符（＄）、或者下划线 _ 开始首字符之后可以是字母（A-Z 或者 a-z），美元符（＄）、或者下划线 _ 或任意数字的任何字符组合不能使用关键字作为变量名或方法名标识符是大小写敏感的合法标识符举例：age、＄salary、_value、__1
复制链接

扫一扫