类型 变量 运算符

复习

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”);*/

}

}

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

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

关键字

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

保留字：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。它会报错的

数据类型

基本数据类型表

注意：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值

 && & 参考串连电路

 || | 参考并连电路

 ！

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