Java学习二

文章目录

JAVA基础语法
- 三种注释
- 标识符
- - - - 标识符注意点：
- 数据类型
- 字节
- 拓展
- 类型转换
- 变量
- 变量作用域
- 常量
- 运算符
- - - - 三元运算符
- 包机制
- JavaDoc

JAVA基础语法三种注释

单行注释：// 注释
多行注释：
文档注释（JavaDoc): / ** *注释 */

标识符

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

常见标识符：abstract、assert、boolean、break、byte、case、catch、char、continue、default、do、enum、extends、final、for、goto、if、instanceof、int、interface、new、package、private、return、strictfp、short、switch、synchronized、this、transient、void、class、double、finally、implements、long、protected、static、throw、volatile、const、else、float、import、native、public、super、throws、while.

标识符注意点：

1、所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始（没有数字）

2、首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或数字的任何字符组合。
3、不能使用关键字作为变量名或方法名。
4、标识符是大小写敏感的。
5、合法标识符举例: age, $salary, _value,_1_value
6、非法标识符举例: 123abc, -salary, #abc
7、可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音。

数据类型

强类型语言：要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用长。
弱类型语言

Java的数据类型分为两大类
◆基本类型(primitive type)
◆引用类型 (reference type)

基本数据类型( Primitive Type)：
数值类型：
整数类型：
byte占1个字节范围:-128-127
short占2个字节范围:-32768-32767
int占4个字节范围:-2147483648-2147483647
long占8个字节范围: -9223372036854775808-9223372036854775807
浮点类型：
float占4个字节
double占8个字节
字符类型：
char占2个字节
boolean类型:占1位其值只有true和false两个

引用数据类型( Reference Type )：
类、接口、数组

注意点：
1、Long类型要在数字后面加个L;
2、float类型要在数字后面加个F;
3、//字符
char name = ‘A’(一个字);
4、//字符串,String不是关键字,类
//String namea= “AA”;
5、//布尔值:是非、
boolean flag = true;
boolean flag = false;

字节

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

1bit表示1位
1Byte表示一个字节1B=8b
1024B=1KB
1024KB=1M
1024M=1G.

拓展

整数拓展
进制
二进制0b
十进制
八进制0
十六进制0x

public class B {
    public static void main(String[] args) {
        int a=10;
        int b=010;//八进制0
        int c=0x10;//十六进制0x
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

字符拓展

public class B {
    public static void main(String[] args) {
        char c1 = 'A';
        char c2 = '中';


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

    }
}

/所有的字符本质还是数字
//编码 Unicode表: (97= a 65 =A) 2字节 0- 65536 Excel 2 16= 65536
// U0000 UFFFF

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

浮点数拓展

转义字符
// t 制表符
// n 换行
//…

System.out.println("HellonWorld");

布尔值扩展

boolean flag = true;
if (flag==true){ } //新手
if (flag){ } //老手

类型转换

◆由于Java是强类型语言,所以要进行有些运算的时候的,需要用到类型转换。
由低到高
byte, short, char-> int -> long-> float -> double

◆运算中,不同类型的数据先转化为同一类型,然后进行运算。
◆强制类型转换 (类型)变量名（高->低)

public class C {
    public static void main(String[] args) {
        int A=128;
        byte B=(byte)A;//内存溢出
        System.out.println(B);
    }
}

◆自动类型转换（低->高）

public class C {
    public static void main(String[] args) {
        int A=128;
        double B=A;
        System.out.println(B);
    }
}

内存溢出

public class C {
    public static void main(String[] args) {
        //操作比较大的数的时候,注意溢出问题
        // 数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int al = money*years; //-1474836480 ,计算的时候溢出了
        long al2 = money*years; //默认是int,转换之前已经存在问题了
        long al3 = money*((long) years); //先把一个数转换为Long
        System.out.println(al3);
    }
}

注意点：
1、不能对布尔值进行转换
2、不能把对象类型转换为不相干的类型
3、转换的时候可能存在内存溢出，或者精度问题

public class D {
    public static void main(String[] args) {
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89f);//-45
    }
}

变量

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

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

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

变量作用域

◆类变量
◆实例变量
◆局部变量

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

public class D {
    //类变量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 D();
        D d = new D();
        System.out.println(d.age);
        System.out.println(d.name);

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

    }

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

变量的命名规范
1、所有变量、方法、类名:见名知意
2、类成员变量:首字母小写和驼峰原则: monthSalary
3、局部变量:首字母小写和驼峰原则
4、常量:大写字母和下划线: MAX_ VALUE
5、类名:首字母大写和驼峰原则: Man, GoodMan
6、方法名:首字母小写和驼峰原则:run(), runRun()

常量

◆常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
◆所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变。

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

◆常量名一般使用大写字符。

public class E {
    //修饰符,不存在先后顺序
    static final double PI = 3.14;//或者 final static double PI = 3.14;

    public static void main(String[] args){

        System.out.println (PI);

    }

}

运算符

◆Java 语言支持如下运算符:
算术运算符: +,-, *, /, %, ++, –
赋值运算符 =
关系运算符: >, <, >=, <=, ==, != instanceof.
逻辑运算符: &&, II, !
位运算符: &,I, ^, ~, >>, <<, >>>
条件运算符 ?:
扩展赋值运算符: +=,-=,/=

自增,自减

public class F {
    public static void main(String[] args) {
        //++.自增,自减 一元运算符
        int a= 3;

        int b= a++;//执行完这行代码后,先给b赋值,再自增
        // a = a + 1;
        System.out.println (a);


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

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

逻辑运算符

public class G {
    //逻辑运算符
    public static void main(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)); //選辑或运算:两个变量有一个为真,则结果就为true
        System.out.println("! (a && b) :"+!(a&&b)); //如果是真,则变为假,如果是假则变为真

        //短路运算
        int c = 5;
        boolean d = (c<4) &&(c++<4);
        System.out.println(d);
        System.out.println(c);
    }
}

多个变量运算时有long类型结果为long类型，否则为int型。

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

    System.out.println(2<<3);

    }
}

字符串连接符

public class i {
    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+"");
    }
}

三元运算符

public class J {
    //三元运算符
    public static void main(String[] args) {
        //x ? y: z
        // 如果x==true,则结果为y,否则结果为z

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

}

包机制

◆为了更好地组织类,Java提供了包机制,用于区别类名的命名空间。
◆包语句的语法格式为:

package pkg1[. pkg2[. pkg3...]];

◆一般利用公司域名倒置作为包名;
◆为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能

import package1[.package2...]. (classname | *);

JavaDoc

◆javadoc命令是用来生成自己API文档的

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

Java学习二

Java相关栏目本月热门文章