02数据类型 +变量类型

一、数据类型

1.1 基本数据类型

1.1.1 数字类型

1.1.1.1 整型

单词	含义	占用内存	取值范围	默认值
byte	字节型	1字节（8bit）	-128~127	0
short	短整型	2字节（16bit）	-32768~32767	0
int	整型	4字节（32bit）	-2^31 ~ 2^31-1	0
long	长整型	8字节（64 bit）	-2^63 ~ 2^63-1	0L

1.1.1.2 浮点类型

单词	含义	占用内存	取值范围	默认值
float	单精度型	4字节（32bit）	比较大	0.0f
double	双精度型	8字节（64 bit）	比较大	0.0d

1.1.2 布尔类型boolean

单词	含义	占用内存	取值范围	默认值
boolean	布尔	1字节	false,true	false

1.1.4 字符类型char

单词	含义	占用内存	取值范围	默认值
char	字符	2字节（16bit）	\u0000(0) ~\uffff(65535)	-

1.1.5 获取二进制位数

语法： 数据类型.SIZE

System.out.println(Byte.SIZE);
System.out.println(Short.SIZE);
System.out.println(Integer.SIZE);
System.out.println(Long.SIZE);
System.out.println(Float.SIZE);
System.out.println(Double.SIZE);
System.out.println(Character.SIZE);

1.1.6 获取最大值（最小值）

语法： 数据类型.MAX_VALUE

System.out.println(Byte.MAX_VALUE);
System.out.println(Short.MAX_VALUE);
System.out.println(Integer.MAX_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println(Float.MAX_VALUE);
System.out.println(Double.MAX_VALUE);
System.out.println( (int)Character.MAX_VALUE);

1.2 引用数据类型

语法：类名 变量名 = new 构造函数名(参数);

数据类型	默认值
对象	null
数组	null
String	null

特点：

1. 引用类型变量，由类的构造函数创建。
2. 通过引用类型变量，可访问其对应的对象。
3. 引用类型变量声明类型后，类型就不能被改变了。

Animal dog = new Animal(“旺财”);
// 构造函数名必须同类名。

二、变量类型

2.1 局部变量

语法：数据类型 局部变量名 = 变量值;
特点：

项目	说明
声明位置	在方法、构造方法或者语句块中。
声明时间	先赋值后使用。
生命周期	定义位置开始，定义位置所在花括号的结束。
可见性	只在声明它的方法、构造方法或者语句块中可见。
分配地点	栈上。
默认值	无。

public class MainEntrance {
	public static void main(String[] args) {		
		// 局部变量的生命周期：定义位置开始，定义位置所在花括号的结束。		
//		System.out.println(localVariable); // 报错：原因定义变量位置在其下方。
		int localVarible1 = 5;
		System.out.println(localVarible1); // 不报错：原因定义变量位置在其上方。		
		// 分支结构和循环结构中定义的变量，不可用于外部。
	}
}

2.2 成员变量（实例变量）

语法：访问修饰符 数据类型 成员变量名 = 变量值;
特点：

项目	说明
声明位置	类中，方法、构造方法和语句块之外。
声明时间	使用前或使用后。声明时或构造方法中。
生命周期	对象实例化时开始，对象销毁时销毁。
可见性	使用访问修饰符private时，同类中的方法、构造方法或者语句块可见。使用访问修饰符public时，可对其子类可见。
分配地点	堆上。
默认值	数值型（0）、布尔型（false）、引用型（null）。
使用频率	至少被一个方法、构造方法或者语句块引用，以供外部通过方法使用成员变量。
访问方法	变量名直接访问。但在静态方法和其他类中，ObejectReference.VariableName。

2.3 类变量（静态变量）

语法：访问修饰符 static [final] 数据类型 类变量名 = 变量值;
特点：

项目	说明
声明位置	类中，方法、构造方法和语句块之外。
声明时间	使用前。
生命周期	程序开始时创建，在程序结束时销毁。
可见性	使用访问修饰符private时，同类中的方法、构造方法或者语句块可见。使用访问修饰符public时，可对其它类可见。
分配地点	方法区上。静态存储区。
默认值	数值型（0）、布尔型（false）、引用型（null）。
使用频率	除了被声明为常量（大写）外很少使用。经常被声明为常量。
访问方法	变量名直接访问。但在静态方法和其他类中，ClassName.VariableName。

注意：如果一个实例改掉了类变量的值，其他实例调用此类变量值时也是改动后的。

2.4 静态成员与非静态成员的区别

说明：

1. 静态成员——类变量 + 类方法
2. 非静态成员——成员变量 + 非静态方法。

主函数入口：

package teacher;
import java.util.Scanner;
public class JudgeAdult {
	public static void main(String[] args) {
		// 获取控制台输入的数据。
		Scanner input1 = new Scanner(System.in);
		// 获取姓名
		String name = input1.nextLine();
		// 获取年龄
		int age = input1.nextInt();
		input1.nextLine();
		// 获取性别
		String sex = input1.nextLine();
		// 对象创建：调用构造函数
		Student stu = new Student(name,age,sex);		
// ===========================非静态成员的调用： 只能通过对象名调用。=====================		
		// 非静态方法的调用。
		stu.judgeAdult2(); // 对象名.非静态方法名();
		// 非静态变量的调用。
		System.out.println(stu.grade2); // 对象名.非静态变量名;
// ===========================静态成员的调用：通过对象名（或类名）调用。但建议使用类调用=====================		
		// 静态方法的调用：
 		Student.information2(); // 类名.静态方法名();
 		stu.information(); // 对象名.静态方法名();
		// 静态变量的调用
 		System.out.println(Student.grade); // 类名.静态变量名;
 		System.out.println(stu.grade); // 对象名.静态变量名;
		
	}
	
}

学生类：

package teacher;
public class Student {
// ==============================构造函数========================		
	// 构造函数：用于创建对象。
	public Student(String name, int age , String sex ){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
// ==============================  变量  ========================		
	// 成员变量（非静态变量）：生命周期，跟随对象。非静态变量。
	String name;
	int age;
	String sex;
	int grade2 = 45;
	// 静态变量：
	static int grade = 23;
// ==============================  方法  ========================		
	// 非静态方法
	public void judgeAdult(){
		if((this.age >= 25 && this.sex.equals("男") ) || (this.age >=22 && this.sex.equals("女"))){
			System.out.println(this.name + "已经成年！");
		}else{
			System.out.println(this.name + "尚未成年！");
		}
	}
	// 静态方法：
	public static void information(){
		System.out.println("每个学生都有姓名、性别和年龄！");
	}
// ==============================同类调用========================		
	// 非静态方法
	public void judgeAdult2(){
		judgeAdult(); // 调用非静态方法
		information(); // 调用静态方法
		System.out.println(grade); // 调用静态变量
		System.out.println(sex); // 调用非静态变量		
	}			
	// 静态方法：直接调用时，只能调用静态成员。
	public static void information2(){
		information(); // 调用静态方法
		System.out.println(grade); // 调用静态变量
	}	
}

三、 常量

语法：final 数据类型 常量名 = 常量值;
特点：

1. 常量名，常常用大写字母表示。
2. 常量值，一旦声明，不可再更改。
3. 数字常量 + 字符常量 + 字符串常量 。

final double PI = 3.14;

四、 转义字符

转义字符	含义	转义字符	含义
\n	换行	\r	回车
\s	空格	\t	制表符
\f	换页符	\b	退格
\"	双引号	\’	单引号
\	反斜杠	\ddd	八进制字符
\uxxxx	16进制Unicode字符

五、方法参数的传递机制

基本数据类型：值传递，原值不变。
引用数据类型：址传递，原值改变。
主函数入口：

package mathod;
public class TestPassByValue {
  public static void main(String[] args){	  
	  // 基本数据类型传递机制： 不改变原值。
	  int number1 = 1;
	  int number2 = 2;	  
	  System.out.println(number1 + " , " + number2); // number1 = 1 , number2 = 2
	  ConstructorDemo.swap(number1,number2); // 交换前：n1 = 1 , n2 = 2。交换后：n1 = 2 , n2 = 1
	  System.out.println(number1 + " ," + number2); // number1 = 1 , number2 = 2  
	  
	  ConstructorDemo stu = new ConstructorDemo(3,"张三");
	  stu.introduce();
	  
	  ObjectSwap stu2 = new ObjectSwap();
	  stu2.name = "张三";
	  stu2.clazz = 3;	  
	  // 引用数据类型传递机制：改变原值。
	  System.out.println(stu2.name); // 张三
	  stu2.swap(stu2); // 参数为stu2对象。李四是4班学生
	  System.out.println(stu2.name); // 李四
  }
}

值传递Java源文件：

package mathod;
public class ConstructorDemo {
	public ConstructorDemo(int clazz, String name){
		this.clazz = clazz;
		this.name  = name;
	}
	int clazz;
	String name;
    // 数字交换。
	public static void swap(int n1, int n2){
		System.out.println("交换前：n1 = " + n1 + " , n2 = " + n2);
		int temp = n1;
		n1 = n2;
		n2 = temp;
		System.out.println("交换后：n1 = " + n1 + " , n2 = " + n2);	  
	}
	// 自我介绍
	public void introduce(){
		System.out.println(this.name + "是" + this.clazz + "班的学生"); 
	}
	
}

址传递Java源文件：

package mathod;
public class ObjectSwap {
	// 构造函数
	public ObjectSwap(){		
	}
	// 成员变量
	int clazz;
	String name;
	// 形参为对象的普通方法
	public void swap(ObjectSwap stu3){
		stu3.clazz++;
		stu3.name = "李四";
		System.out.println(this.name + "是" + this.clazz + "班学生");
	}
}