0
点赞
收藏
分享

微信扫一扫

Java-类型 变量 运算符

向上的萝卜白菜 2022-03-25 阅读 111


类型 变量 运算符

复习

Java程序结构

public class 类名 {

public static void main(String[] args){

//……语句

}

}

备注:

1、类名必须和文件名一致

2、java语言严格区分大小写

3、每一条语句都必须以分号结束

4、每一条语句单独占一行

5、命名要按照驼峰式命名(XiWangDaJiaXueHao JAVA) 类名首字母必须大写 变量名开头必小写

6、命名要见名知意

Eclipse工具的使用:(Java c语言 php pyson)

1、创建项目

①new>project>java project {next} > 命名(demo01)> {next> finish}

②src(new class) > 命名(Helloworld) {命名中不能有空格}

2、创建类并编写源代码

public class 类名{

public static void main(String[] args){

//…Java语句

}

}

3、编译源代码

右键空白(Run As)

4、运行程序

①.保存相当于执行Java命令

println() print("\n")

\n:将光标移动到下一行的第一格

\t:将光标移到下一个水平制表位置

正课

1、 单行注释 //aaaaaaaaaaa

2、 多行注释 /* ​/
3、 文档注释 /
​*

*/

public class Demo {

/**
* 这是程序执行的入口
* @param args
*/
public static void main(String[] args) {
//System.out.println("aaaaaaaaaaa");
System.out.println("aaaaaaaaaaa");
System.out.println("aaaaaaaaaaa");

/* System.out.println(“aaaaaaaaaaa”);

System.out.println(“aaaaaaaaaaa”);

System.out.println(“aaaaaaaaaaa”);

System.out.println(“aaaaaaaaaaa”);*/

}

}

任何一门语言都是由各种元素组成的:

关键字 数据类型 变量 表达式 运算符 语句 流程控件

关键字

某种语言已经为其赋予了特殊含义的的英文单词。

​​abstract​​抽象

​​assert​​维护

​​boolean​​

break

​​byte​​

case

​​catch​​

​​char​​

​​class​​

Const常量

continue

​​default​​违约

​​do​​

​​double​​

​​else​​

​​enum​​

​​extends​​扩充

​​final​​最终

​​finally​​

float

​​for​​

goto

​​if​​

​​implements​​工具

​​import​​输入

​​instanceof​​运算符

​​int​​

​​interface​​交界面

long

Native本国

new

​​package​​

​​private​​

​​protected​​

​​public​​

​​return​​

​​strictfp​​严格

​​short​​

​​static​​

​​super​​极好的

​​switch​​

​​synchronized​​同步/线程

​​this​​

​​throw​​抛

​​throws​​

​​transient​​短暂的

try

​​void​​空的

​​volatile​​挥发

​​while​​

保留字:goto const

要点:

默认:

整形int 浮点型double

避免相似:

L与1避免相似

范围转换:

Int到long:4~8L

Double到float:8到4f 15 6

特别范围:

Char0~2^16

int与Integer的区别

Integer是其包装类,注意是一个类。

提供包装类的原因

类型间转化,通过各种方法的调用。否则 你无法直接通过变量转化。

核心:

Integer Double 通过.toString转字符串

.valueOf(“12”); .parseInt(“12”);(字符串通过上+此——转化成需要字符)

特殊String a = new integer(12).toString();

例:

1integer转其他

2(“”)string转其他.valueOf(“12”); .parseInt(“12”);

3(任意.valueOf “” ,true)转换成

特殊

4new类。Tostring

5《包装类》

int a=0;

String result=Integer.toString(a);

//通过包装类来实现转化的

int num=Integer.valueOf(“12”);

int num2=Integer.parseInt(“12”);

double num3=Double.valueOf(“12.2”);

double num4=Double.parseDouble(“12.2”);

//其他的类似。通过基本数据类型的包装来的valueOf和parseXX来实现String转为XX

String a=String.valueOf(“1234”);//这里括号中几乎可以是任何类型

String b=String.valueOf(true);

特殊

new

String c=new Integer(12).toString();//通过new包装类的toString()也可以

String d=new Double(2.3).toString();

用泛型

List nums;

这里<>需要类。如果你用int。它会报错的

数据类型

Java-类型 变量 运算符_java

基本数据类型表

类型名称

长度(占计算机空间)

表示数值的范围

举例

boolean

1bit

true false

整型数值

byte

1个字节

-128~127 -27 ~ 27-1

short

2byte

-32768~32767 -215 ~ 215-1 3万

int

4byte

-231~ 231-1

long

8byte

-263 ~ 263-1

浮点数值

float

4byte 个不含. 注意(8科学计数法)

有自己的算法,远远大于2N

double

8byte 不含. 注意(17科学计数法)

char

2byte

0 ~ 216-1 一对单引号括起来的单个字符

都是正数

注意:lfd

\1. 对于整形数据,java​默认是int****类型​。

\2. 对于​整形数据​,在正确的范围之内java会​自动对其进行类型转换​。

\3. 对于带小数点的数,java​默认它是double****类型的​。

\4. 在正确的范围值内,字符类型和整形类型之间可以相互转换。

\5. 1个字节128,由于原码,反码(+0,-0),补码(10000000 代表-128 ,0代表0~127)

变量

变量是内存中一串连续空间的名称

变量的定义

数据类型 变量名

变量的赋值

1

数据类型 变量名;

变量名 = 值

2

数据类型 变量名 = 值

注意:临界值范围

byte short int long 整形范围内可正常书写

// byte byte11 = (byte)0; //强制类型转换

short 强制类型转换

char ““ 或者 ‘’中不能为空 只能写一个字符

特殊取

float f4 = 2147483648L;

字符 和 整数大类型转换

示例:

public class ZHUSHI {

public static void main(String[] args) {

// boolean

// 先定义变量,再赋值

boolean b1;

b1 = false;

// 定义变量并赋值

boolean b2 = true;

System.out.println("-----------------------");

// byte

byte byte1 = -128;

byte byte2 = 127;

// 强制类型转换 不要越界否则产生随机数

byte byte3 = (byte)127;

System.out.println("-----------------------");

// short

short s1 = -32768;

short s2 = 32767;

System.out.println("-----------------------");

// int

int i1 = 2147483647;

int i2 = -2147483648;

System.out.println("-----------------------");

// long

long l1 = -9223372036854775808L;

long l2 = 9223372036854775807L;

System.out.println("-----------------------");

// float

// 未转换 接整形 第8位出现四舍五入 共9位 由于L证明有效数字6位精准 不定 科学计数未知

float f1 = 2147483647;

float f2 = -2147483648;

float f3 = 9223372036854775807L;

/* float f3 = 0.0;

整形可付给浮点数 小范围给大范围

小数默认doublue 给 float 需要类型转换

*/

System.out.println(f1);

System.out.println(f2);

System.out.println(f3);

// 转换类型f || F

float f4 = 2147483692.0f;

float f5 = 92233720368547758071234561F;

System.out.println(f4);

System.out.println(f5);

System.out.println("-----------------------");

// double

// 未转换 long下17位精准到18位开始估读

double d1 = 9223372036854775807L;

double d2 = -9223372036854775808L;;

double d3 = 2147483647;

System.out.println(d1);
System.out.println(d2);
System.out.println(d3);

// 类型转换

double d4 = 13543153486846846846864684846434158537d;

double d5 = 0.0;

double d6 = 3271947123498321741239847321984712.0;

System.out.println(d4);

System.out.println(d5);

System.out.println(d6);

System.out.println("-----------------------");

// char

//单引号内无内容char c1 = ‘’;

char c1= ’ ';

char c2 = ‘a’;

//char c3 = ‘abc’;

char c4 = 2;
char c5 = '0';

//不可用“” 字符‘’
System.out.println("aaaaaaaaaaaaaa");
System.out.println(c4);
System.out.println(c5);
System.out.println("--------字符变int-------------");
int i7 = 'a';
System.out.println(i7);
int i8 = '?';
System.out.println(i8);
}

}

数学运算符

      • / %
        (整数相除默认取整)
      • / %(取余)
        public static void main(String[] args) {
        int a =89;
        System.out.println(a/3);//默认取整
        System.out.println(a%3);//取余

        System.out.println(a*1.0/3);
        float b = 89;
        System.out.println(b/3);
        double c = 89;
        System.out.println(c/3);
        }

赋值运算符

Int a = 89 (将数字89赋给int类型的a)

=

*= a ​= b a = a​b

/= a /= b a = a/b

%= a %= b a = a%b

public static void main(String[] args) {

int a = 89;// 将数字89赋给int类型的变量a

int b = 4;

a ​= b; // a= a​b;

System.out.println(a);

a = 89;
a /= b; // a =a/b;
System.out.println(a);

a = 89;
a %= b; // a = a%b;
System.out.println(a);
}

比较运算符

比较运算符结果是boolean值


(大于) <(小于)
==(等于) >=(大于等于)
<=(小于等于)!=(不等于)


比较运算符的结果是boolean值


< == >= <= !=
public static void main(String[] args) {
int a = 4;
int b = 12;
System.out.println(a > b);
System.out.println(a < b);
System.out.println(a == b);
System.out.println(a >= b);
System.out.println(a <= b);
System.out.println(a != b);
}


自增/自减

(只能作用于变量)

谁在前面先用谁

++ –

++ a++ a= a+1

– a-- a= a-1

只能作用于变量

public static void main(String[] args) {

int a =4;

a ++;

System.out.println(a);

a --;

System.out.println(a);

++a;

System.out.println(a);

–a;

System.out.println(a);

}

谁在前面先计算谁

public static void main(String[] args) {

int a = 3;

int b = 8;

System.out.println(a++);

System.out.println(a);

System.out.println(++b);

System.out.println(b);

}

逻辑运算符

只有Boolean值/表达式才能参与逻辑运算

&& 与 & 参考串联电路

|| 或 | 参考并联电路

! 非

&& || 起短路作用

短路:如果已经明确结果了,就不再计算后面的式子

只有boolean值/boolean表达式才能参与逻辑运算

逻辑运算的结果是boolean值

 && & 参考串连电路

Java-类型 变量 运算符_数据类型_02

 || | 参考并连电路

Java-类型 变量 运算符_包装类_03

 !

public static void main(String[] args) {

boolean res1 = true && true;

System.out.println(res1);

boolean res2 = true && false;
System.out.println(res2);

boolean res3 = true & true;
System.out.println(res3);

boolean res4 = false & true;
System.out.println(res4);

boolean res5 = true || true;
System.out.println(res5);

boolean res6 = false || true;
System.out.println(res6);

boolean res7 = true | true;
System.out.println(res7);

boolean res8 = true | false;
System.out.println(res8);

boolean res9 = !true;
System.out.println(res9);

boolean res10 = !false;
System.out.println(res10);

}

public static void main(String[] args) {
boolean b1 = true;
boolean b2 = true;

boolean res = b1 && b2;
System.out.println(res);

boolean res2 = (3 > 5) && (7 < 6);
System.out.println(res2);
}

&& || 具有短路作用

短路:如果结果已经明确了,就不再计算后面的式子

public static void main(String[] args) {

int a = 3;

int b = 8;

boolean res = (a++ > 3) && (–b< 8);

System.out.println(res);

System.out.println(a);

System.out.println(b);

}

public static void main(String[] args) {
int a = 3;
int b = 8;
boolean res = (a++ > 3) & (--b< 8);
System.out.println(res);
System.out.println(a);
System.out.println(b);
}

public static void main(String[] args) {
int a = 3;
int b = 8;
boolean res = (a++ > 3) || (--b< 8);
System.out.println(res);
System.out.println(a);
System.out.println(b);
}

public static void main(String[] args) {
int a = 3;
int b = 8;
boolean res = (a++ > 3) | (--b< 8);
System.out.println(res);
System.out.println(a);
System.out.println(b);
}

位运算符

扩大或缩小为原来的2的N次幂倍

采用位运算,可以快速的计算2的多少次方

<< 向左移位,扩大


public static void main(String[] args) {
System.out.println(1<<4);
System.out.println(16>>3);
System.out.println(129>>5);
//129/2^5=129/32=
}



举报

相关推荐

Java-数据类型以及运算符

Java-赋值运算符

Java-基础运算符

Java-算术运算符

Java-位运算符

Java-关系运算符

Java-条件运算符

JAVA-数据类型与运算符笔记

Java-逻辑运算符

0 条评论