Java基础

文章目录

Java基础
- 注释、标识符、关键字
- - 注释
  - 关键字
  - 标识符
- 数据类型
- - 数据类型扩展及面试题分析
- 类型转换
- 变量、常量
- - 变量
  - - 变量作用域
  - 常量
  - 变量的命名规范
- 运算符(operator)
- - 二元运算符
  - 关系运算符
  - 一元运算符
  - 逻辑运算符
  - 位运算(面试题)
  - 字符串连接符(面试题)
  - 三元运算符
- 包机制、JavaDoc
- - 包机制
  - JavaDoc

Java基础注释、标识符、关键字注释

平时编码，在代码量较少的时候，可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
主释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范
三种注释

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释
        System.out.println("helloworld");

        
        
        
    }
}

关键字

数据类型：boolean、int、long、short、byte、float、double、char、class、interface。
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。
动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new。
保留字：true、false、null、goto、const。

标识符

标识符是大小写敏感的

public class Demo01 {
    public static void main(String[] args) {
//所有的标识符都应该以字母(a-z或A-Z)，美元符($)、或者下划线(_)开始
        String Ahello = "felks";
        String hello = "felks";
        String $hello = "felks";
        String _hello = "felks";
        //否则如下会报错
        //String #hello = "felks";
        //String *hello = "felks";
        //String 2hello = "felks";

//首字符之后可以是字母(a-z或A-Z)，美元符($)、或者下划线(_)或 数字 的任何字符组合
        String _1 = "feliks";
        //#等特殊字符会报错
        //String _# = "feliks";
        //String _% = "feliks";

//不能使用关键字作为变量名或方法
        //String case = "felks";
        //String class = "feliks";

//标识符是大小写敏感的
        String Man = "feliks";
        String man = "feliks";

//合法标识符举例：age,$salary,_value,__1_value
//非法标识符举例：123abc,-salary,#abc

//可以使用中文命名，但不建议使用，一般也不这样使用
        String 阿飞 = "feliks";
        System.out.println(阿飞);
    }
}

数据类型

Java是一种强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

优点：安全性高缺点：速度较慢

与之相对的弱类型语言

如VBscript、Javascript等

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

Java的数据类型分为两大类

基本类型(primitive type)
引用类型(reference type)

代码中尝试，通过错误使用可加深印象

public class Demo02 {
    public static void main(String[] args) {
        //8大基本数据类型

        //整数
        //Integer  可点进去看最大最小值
        //Byte

        int num1 = 10; //最常用
//      byte num2 = 200;//超过-128--127报错
        short num3 = 30;
        long num4 = 30L; //Long类型要在数字后面加个L

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

        //字符
//      char name = '阿飞'; 两个字会报错
        char name = '飞';

        //字符串，String不是关键字，是类
        String name1 = "阿飞";

        //布尔值：是非
        boolean flag = true;
        boolean flag1 = false;
    }
}

顺便一提：什么是字节？

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

数据类型扩展及面试题分析

整数拓展:

进制二进制0b开头

十进制

八进制0开头

十六进制0x开头

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

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
    }
}

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

BigDecimal入口

//用BigDecimal    数学工具类 //======================================================

        //float   是有限的，离散的  存在舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
pulic class Demo05{
    public static void main(String[] args){
        float f = 0.1f;//0,1
        double d = 1.0/10;//0.1
        System.out.println(f==d);//false

        float d1 = 232323232323232f;//大数
        float d2 = d1+1;
        System.out.println(d1==d2);//true
    }
}

字符拓展

public class Demo06{
    public static void main(String[] args){
        char c1 = 'a';
        char c2 = '陈';

        System.out.println(c1);
        System.out.println((int)c1);//强制转换
//分别输出
//a
//97
        System.out.println(c2);
        System.out.println((int)c2);//强制转换
//分别输出
//陈
//38472
        //原理
        //所有的字符本质还是数字
        //char类型涉及到编码问题
        //Unicode 编码可以处理各种语言文字，占2个字节 0-65536  最早的Excel表最长只有2^16=65536
        //Unicode表：(97 = a  65 = A....)
        //U0000 UFFFF

        //Unicode编码表示方式
        char c3 = 'u0061';//a
        //‘u’表示转义
        System.out.println(c3);
//输出a

        //转义字符
        //t    制表符
        //n    换行
        //...
        System.out.println("hellotworld");
        System.out.println("====================");
        
        
        String sa = new String("feliks");
        String sb = new String("feliks");
        System.out.println(sa==sb);
        //false

        String sc = "feliks";
        String sd = "feliks";
        System.out.println(sc==sd);
        //true
        //等到对象时  再从内存分析
    }
}

布尔值扩展

public class Demo07{
    public static void main(String[] args){
        boolean flag = true;

        if (flag==true){}
        if (flag){}//二者功能相同更精简
        //Less is more  代码要精简易读
    }
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

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

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

强制转换
自动转换

public class Demo05 {
    public static void main(String[] args) {
        int i= 128;
        //强制转换
        byte b = (byte)i;//内存溢出
        //自动转换
        double d = i;

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

        System.out.println(i);//128
        System.out.println(b);//-128 因为byte范围-128~127,内存溢出了
        System.out.println(d);//128.0

        

        System.out.println("======测试精度问题======");
        System.out.println((int)23.7);//23
        System.out.println((int)-45.67f);//-45

        System.out.println("======char======");
        char c = 'a';
        int e = c+1;//char->int低到高自动转换
        
        System.out.println(e);//98
        System.out.println((char)e);//b
    }
}

扩展：操作大数时的溢出问题

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性：数字之间可以用下划线分割
        int money = 10_0000_0000;
        int year = 20;

        int total = money*year;//-1474836480  计算的时候溢出了
        long total2 = money*year;//默认是int，转换之前已经存在问题了，所以还是负数。

        System.out.println(total);//-

        long total3 = money*(long)year;
        System.out.println(total3);//先把一个数转换为long,正确输出√

        //这样也可以诶√
        long years = 20l;
        long total4 = money*years;
        System.out.println(total4);

    }
}

变量、常量变量

变量就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

	type	varName	[=value]	[{,varName[=value]}];
//数据类型	 变量名	=值
//可以使用逗号隔开来声明多个同类型变量（不建议使用）

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

public class Demo07 {
    public static void main(String[] args) {
//      int a=1,b=2,c=3;//程序可读性差

        //基本类型
        int a = 1;
        char x = 'X';
        double pi =3.14;
        //...
        //引用类型
        String name = "阿飞";
    }
}

代码体验

public class Demo08 {

//类变量   static
    static double salary = 2500;

    //属性：变量

//实例变量：在类里面，方法外面。
    //实例变量从属于对象：如果不自行初始化，这个类型的默认值 0 0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name="feliks";
    int age;

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

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

        //变量类型  变量名字 = new Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.name);

//类变量   static
        System.out.println(salary);
    }

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

    }
}

变量作用域

暂且学会static、final即可

类变量
实例变量
局部变量

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

常量

常量(Constant)：初始化(initialize)后不能再改变值！也不会变动的值
所谓常量可以理解成为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
关键字，final

final 常量名=值
final double PI = 3.14

常量名一般使用大写字母

public class Demo09 {

    //修饰符，不存在先后顺序
    //static final换位后不影响
    static final double PI = 3.14;

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

变量的命名规范

所有变量、方法、类名：要求见名知意
类成员变量：首字母小写和驼峰原则：除了第一个单词以外，后面的单词首字母大写：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man,SpiderMan
方法名：首字母小写和驼峰原则：run()，runOver()

运算符(operator)

优先级

Java语言支持如下运算符
算术运算符: +，-，，l，%，++，–***
赋值运算符: =
关系运算符:>，<，>=，<=，==，!= instanceof
逻辑运算符: &&，||，!
位运算符: &，|，^，~，>>，<<，>>>(了解!! ! )
条件运算符: ? ∶
扩展赋值运算符:+=，-=，*=，/=

二元运算符

package operator;

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

public class Demo02 {
    public static void main(String[] args) {
        long a = 1234567891012L;
        int b = 123;
        short c = 10;
        byte d = 8;

        //两个或多个操作数中有一个类型为Long，那么结果类型为Long
        System.out.println(a+b+c+d);//Long
        //没有Long时，结果都为Int,无关有无Int
        System.out.println(b+c+d);//Int
        System.out.println(c+d);//Int
        //有Doubele，结果为Double
        System.out.println((double)c+d);//Double
    }
}

关系运算符

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符的返回结果：true,false  布尔值
        //if
        int a = 10;
        int b = 20;
        int c = 21;

        //取余，模运算
        System.out.println(c%a);//1  c/a -> 21/10 = 2...1

        System.out.println(a>b);//false
        System.out.println(a 
一元运算符 
public class Demo04 {
    public static void main(String[] args) {
        //++    --  自增、自减   一元运算符
        int a = 3;

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

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

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //幂运算2^3
        //很多幂运算，会使用一些工具类来操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);//8
    }
}
 
逻辑运算符 
//逻辑运算符
public class Demo05 {
    public static void main(String[] args) {
        //与(and)    或(or)   非(取反)
        boolean a = true;
        boolean b = false;

        //逻辑与运算：同真为真，一假为假
        System.out.println("a && b:"+(a&&b));//false
        //逻辑或运算：一真为真，同假为假
        System.out.println("a || b:"+(a||b));//true
        //取反
        System.out.println(("!(a && b):"+!(a&&b)));//true


        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        //验证：若&&前的为假，则不执行&&后的
        System.out.println(d);//false
        System.out.println(c);
        //输出c=5，说明(c++<4)未被执行，若执行，c应该为6
    }
}
 
位运算(面试题) 
//位运算
public class Demo06 {
    public static void main(String[] args) {
        
        System.out.println(2<<3);
    }
}
 
字符串连接符(面试题) 
public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;//a = a+b
        System.out.println(a);//30

        //字符串连接符  在'+'两侧，只要有一方有String类型，会将另外的操作数都转换成String再进行连接
        System.out.println(a+b);//30
        System.out.println(""+a+b);//1020

        
    }
}
 
三元运算符 
//三元运算符
public class Demo09 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x==true,则结果为y,否则结果为z
        
        int score = 80;
        String s = score < 60 ? "不及格":"及格"; //必须掌握
        System.out.println(s);
        //输出及格
    }
}
 
包机制、JavaDoc 
包机制 
为了更好的组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为： 
package pkg1[.pkg2[,pkg3...]];
 
一般利用公司域名倒置作为包名；net.cqwu
为了能够使用某一包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能 
import package1[.package2...],(classname|*);
 
JavaDoc 
javadoc命令是用来生成自己API文档的 
 
参数信息 
  @author 作者名
@version 版本号
@since 知名需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
  
package net.cqwu.base;


public class Doc {
    String name;

    
    public String test(String name)throws Exception{
        return name;
    }
    //通过命令行    javadoc 参数 Java文件

    //学会查找使用IDEA生产JavaDoc文档！    面向百度编程
    //基础部分的这些知识，会经常用
}

Java基础

Java相关栏目本月热门文章