Java（3）Java入门知识（标识符、注释符、数据类型、运算符、输入与输出）

Java入门知识

Java标识符

自己定义的东西的名字就是标识符(类名，变量名，方法名，包名)

命名规则

1、标识符对大小写敏感

2、关键字不能做标识符

3、可由字母、数字、下划线_ 美元符$

4、不能以数字开头

命名规范(驼峰命名,见名只意)

包名: 全部小写，以域名开头，如：com.sikiedu.tools
类名:第一个单词首字母大写，后面的单词首字母大写
函数和变量名:第一个单词首字母小写，后面的单词首字母大写

类名必须以英文字母开头

要注意命名习惯：

好的命名：

Hello
NoteBook
VRPlayer

不好的命名：

hello （纯小写的）
Good123 （没有意义的名称）
Note_book （带下划线_的名称）
World

Java注释符

单行注释

// (在notepad++里面，ctrl+k添加注释，ctrl+q取消注释)

多行注释

/* balabala

balabala*/

文档注释

/**
 *
 */

Java程序基本结构

public class 类名{
  public表示这是一个公开的class
  在一个class内部可以定义很多的方法：
  返回值 方法名(参数){
  //我们的方法是main，返回值是void，表示没有返回值
  //在方法的花括号中间，语句是真正的执行代码，每一行语句必须以分号结束
  }
}

注意：当我们单击eclipse的类或方法，eclipse可以显示范围

Java数据类型

Java分为两大数据类型

基本数据类型
引用数据类型

从图看到：Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

查看数据类型：使用getClass()函数，如：

System.out.println("I love you".getClass());
//运行结果为 java.lang.String

八大基本类型

八大基本类型都是不可变数据类型

当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。

查看各大基本类型的二进制位数和最大最小值

public class TestReflection {
    public static void main(String[] args) {
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.SIZE);
    }
}
// 其它类型查询方法一样

运行结果为：

127
-128
8

类型的默认值

只定义变量不赋值时会有默认值，如

static byte by; 

static char ch;

数据类型默认值：

引用类型（不可变类型）

在Java中，引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
所有引用类型的默认值都是null。（空值null和空字符串””是不一样的）
引用类型有：类、数组、接口。

字符串String是一个类，也属于引用数据类型,是Java中一个比较特殊的类，它不是Java的基本数据类型之一，但可以像基本数据类型一样使用，声明与初始化等操作都是相同的，如
String s = ‘a’;
拓展：

String 是一个类，

StringBuilder也是一个类

两者都是引用类型，区别是：

String：不可变数据类型

StringBuilder：可变数据类型
String s = "a"; s = s + "b";
//其中s指向了两个内存地址，一个地址中是“a” ，另一个是 “ab”
StringBuilder sb = "a";  sb = "ab";
//StringBuilder是可变数据类型，更改它的时候sb始终指向同一个位置

常量

常量不会发生变化, 常量在程序运行时是不能被修改的。在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

自动类型转换：

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低 ------------------------------------> 高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
```
int i1 = 123; 
byte b = (byte)i1;//强制类型转换为byte
```
转换过程中可能导致溢出或损失精度，例如：
```
int i =128;  
byte b = (byte)i;
```
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
```
(int)23.7 == 23;    
(int)-45.89f == -45
```

隐含强制类型转换：

整数默认为int,小数默认为double类型，因此：

定义long类型时使用方法:

long d =100000000000L;//(末尾不添加L/l会出错)

定义float类型时使用方法:

float e=1.2f; //(末尾不添加F/f会出错)

变量注意事项

作用域(有效范围):定义在哪个大括号内，就在哪里有效，不能同名在同一个作用域里面
在使用之前初始化
一行可以定义多个变量

int x;int y;int z;

int x,y,z;

int x=90,y=2,z=80;

计算机存储单位的原理

1字节=8位

1byte=8bit

1kbyte=1024byte

1mb=mbyte=1024kbyte

1gb=1024mb

B=byteb=bit,宽带100Mb=100/8MB=12.5MB(销售策略，字节与位的区别: B,b)

购买硬盘：16GB=16*1000/1024GB变小了;

特殊值

NaN表示Not a Number 0.0/0
Infinity 无穷大 1.0/0
-Infinity 负无穷大 -1.0/0

进制类型

二进制——输出十进制整型对应的二进制toBinaryString()
八进制
十六进制——输出十进制整型对应的十六进制toHexString()
十进制

Java运算符

算术运算符

+ - * / %(求余)

/ (两边只要有一个是浮点类型结果就是浮点类型)

浮点数运算注意：

很多浮点数无法精确表示，如
```
double a = 0.1
```
计算会有误差，如1-9.0/10
浮点运算中，整型可以自动提升到浮点型

注意类型不自动提升的情况，如，24/5 分子分母都为整型，

解决方法：将其中一个数转为浮点型

赋值运算符

+=,-=,/=,%=

字符串拼接符 +

可以使用+字符对字符串进行组拼，任何类型和字符串相加都会把数据转成字符串，再进行组拼

a+"hello";  //ahello
34+"hello"; //34hello

自增运算符

++ --

 int res1=a++ //顺序:res1=a→a=a+1;(先用了再加1)
 int res2=++a //顺序:a=a+1→res2=a;(先加了1再用)

比较运算符

<> <= >= == != 结果为Boolean类型

逻辑运算符

&&(短路与)-----&逻辑与

&与&&的区别:

两者都表示逻辑与，但是&&还具有短路的功能，即如果第一个表达式为 false，则不再计算第二个表达式，而&没有。

   int a=10,b=10;

   System.out.println(a<5 & (++b)>10);

   System.out.println(b);//结果为11

   a=10;b=10;

   System.out.println(a<5 && (++b)>10 );

   System.out.println(b);//结果为10

   //第二part的第一个判断条件a<5为false之后，不会执行第二个条件

||(短路或) (有一个为真即为true)--------|(逻辑或)

|和||的区别：

两者都表示逻辑或，但是||还具有短路的功能，即如果第一个表达式为 true，则不再计算第二个表达式，而|没有。

! 取反(后面只能跟Boolean逻辑值)

^ 异或 (只有一真一假才为true)

位运算符

**正数: ** 原码、反码与补码相同。

负数：原码(符号位为1) 反码(符号位不变，其余数取反) 补码(反码+1)

9的原码/反码/补码都是00000000 00000000 00000000 00001001

-9的原码10000000 00000000 00000000 00001001
    
-9的反码11111111 11111111 11111111 11110110

-9的补码11111111 11111111 11111111 11110111

计算机存储正数的时候直接存储正数的原码，存储负数的时候直接存储负数的补码。

按位运算符(只针对二进制来说，所以在进行运算之前会转换成二进制，再运算)

&按位与：对应位都是1才是1

 9: 00000000 00000000 00000000 00001001
&7: 00000000 00000000 00000000 00000111
//----------------------------------------
结果 00000000 00000000 00000000 00000001
//所以9&7=1

|按位或：对应位有一个1，就是1
~按位取反：1变0，0变1
^按位异或：对应位不一样才是1

移位运算符

<<左移(高位抛弃，低位补0)

-9: 11111111 11111111 11111111 11110111(补码)
<<3 11111111 11111111 11111111 11110111
//----------------------------------------
补码  11111 11111111 11111111 11110111000
反码  11111 11111111 11111111 11110110111(补码-1)
原码  10000 00000000 00000000 00001001000

//所以-9<<3的结果为-72

>>右移(高位按照符号位补齐，低位抛弃)

-9: 11111111 11111111 11111111 11110111(补码)
>>311111111 11111111 11111111 11110111
//----------------------------------------
补码  11111 11111 11111111 11111111 11110
反码  11111 11111 11111111 11111111 11101 (补码-1)
原码  10000 00000 00000000 00000000 00010
    
//所以-9>>3的结果为-2

>>>>无符号右移(忽略符号位，高位补0，低位抛弃)
```
//自己实验
```

三元运算符 ?: (条件运算符)

语法: 布尔表达式 ? true表达式1 : fasle表达式2

案例:取最大值

int a=100,b=23,c=392;

int maxR = (a>b) ? a : b; 

int maxT = (maxR>c) ? maxR : c;
//(maxR>c)这里可以不使用括号，但是应习惯使用括号，提升代码易读性

System.out.println(maxT);
//392

instance of运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）如：

String name = "James";

boolean result = name instanceof String; 

// 由于 name 是 String 类型，所以返回真true

package day01;

class Sport{

}
class Football extends Sport{

}
public class Test01{
    public static void main(String[] args) {
        Football f=new Football();
        System.out.println(f instanceof Sport); 
    }
}
/*运行结果为ture，因为Football是Sport的子类，
而instanceof可以判断一个对象是否是属于某个类或者某个类的子类*/

Java输入与输出

输入

Java通过 Scanner 类来获取用户的输入，通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据。

步骤：

导入java.util.Scanner
```
import java.util.Scanner;
```

创建Scanner对象

//语法： 
Scanner s = new Scanner(System.in);

使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据
使用scanner.nextLine()读取字符串，使用scanner.nextInt()读取整数

使用next()方法例子

import java.util.Scanner; 
public class ScannerDemo { 
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in); 
		// 从键盘接收数据 
		// next方式接收字符串 
		System.out.println("next方式接收："); 
		// 判断是否还有输入 
		if (scan.hasNext()) {
			String str1 = scan.next();
			System.out.println("输入的数据为：" + str1); 
		} 
		scan.close(); 
	} 
}

/*运算结果
next方式接收：
I love you，krystal
输入的数据为：I
*/

使用nextLine()方法例子：

import java.util.Scanner;

public class ScannerDemo { 

public static void main(String[] args) {

Scanner scan = new Scanner(System.in); 

// 从键盘接收数据 

// nextLine方式接收字符串 

System.out.println("nextLine方式接收："); 

// 判断是否还有输入 

if (scan.hasNextLine()) {

String str1 = scan.nextLine();

System.out.println("输入的数据为：" + str1); 

} 

scan.close(); 

} 

}

运算结果：

next()和nextLine()的区别

next():

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine()：

以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取（使用方法和读取字符串一样）

输出

C语言风格的格式化输出使用:

	System.out.printf();

了解更多占位符的使用：https://www.runoob.com/w3cnote/java-printf-formate-demo.html

使用占位符%xxx , 例子：

    System.out.printf("%sLoves%s%n", "Name", "Zhangsan");

posted @ 2020-08-28 00:05 Whatever_It_Takes 阅读(274) 评论(0) 编辑收藏举报

刷新页面返回顶部

cqzs+nl