Java-类型变量运算符

类型变量运算符

复习

Java程序结构
public class 类名 {
public static void main(String[] args){
//……语句
}
}
备注：
一、类名必须和文件名一致
二、java语言严格区分大小写
三、每一条语句都必须以分号结束
四、每一条语句单独占一行
五、命名要按照驼峰式命名（XiWangDaJiaXueHao JAVA）类名首字母必须大写变量名开头必小写
六、命名要见名知意
Eclipse工具的使用：(Java c语言 php pyson)
一、建立项目
①new>project>java project {next} > 命名（demo01）> {next> finish}
②src（new class） > 命名（Helloworld） {命名中不能有空格}
二、建立类并编写源代码
public class 类名{
public static void main(String[] args){
//…Java语句
}
}
三、编译源代码
右键空白（Run As）
四、运行程序
①.保存至关于执行Java命令
println() print("\n")
\n:将光标移动到下一行的第一格
\t:将光标移到下一个水平制表位置php

正课

一、单行注释 //aaaaaaaaaaa
二、多行注释 /* /
三、文档注释 /*
*/
public class Demo { java

/**
 * 这是程序执行的入口
 * @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”);*/
}
}
任何一门语言都是由各类元素组成的：
关键字数据类型变量表达式运算符语句流程控件es6

关键字

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

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 浮点型doublesvg

避免类似：
L与1避免类似工具

范围转换：
Int到long：4~8L
Double到float:8到4f 15 6this

特别范围：
Char0~2^16url

int与Integer的区别

Integer是其包装类，注意是一个类。
提供包装类的缘由
类型间转化，经过各类方法的调用。不然你没法直接经过变量转化。es5

核心：
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。它会报错的

数据类型

基本数据类型表

	类型名称	长度（占计算机空间）	表示数值的范围	举例
	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 = ab
/= 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= ab;
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值
 && & 参考串连电路

 || | 参考并连电路

 ！
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的多少次方

<< 向左移位，扩大

向右移位，缩小(注意从低位开始减小， >>>无符号的高位都加0)

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=
}

本文同步分享在博客“瑞新”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

Java-类型 变量 运算符

类型 变量 运算符

复习

正课

关键字

要点：