JAVA——数据类型、变量、修饰符、运算符

一、数据类型

1、基本数据【8种】值传递

（1）数字类型【6种】

1. 整数【4种】补码表示

byte：8位，有符号,- 2⁷ ~2⁷-1
short：16位
int：32位
long：64位

byte a=100;
short b=100;
int c=100;
long d=100l;//尾巴l莫忘

2. 浮点数【2种】

float：32位
double：64位

float e=100.1f;//尾巴f莫忘
double f=100.1d;//尾巴d可有可无

（2）布尔类型

boolean：1位

boolean g=true;

（3）字符类型

char：16位

char letter = 'A';

2、引用类型 地址传递

在Java中，引用类型的变量类似于C/C++的指针。
引用类型指向一个对象，指向对象的变量是引用变量。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。

Site site = new Site("Runoob")
int [] arr={1,2,3,4,5};

3、常量

常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量

final double PI = 3.1415927;

4、转义字符序列

【重点】类型转换

低位数可向高位数转换，不会有损失。高位数向低位数转换
如：小杯水向大杯水倒水不会溢出，大杯水向小杯水会溢出
1.自动类型转换

2.强制类型转换
格式：(type)value type`
3.boolean类型不能和其他的类型进行转换

int  a= 123;
byte b = (byte)a;//强制类型转换为byte

二、变量

Java语言支持的变量类型有：

• 类变量：独立于方法之外的变量，用 static 修饰。
• 实例变量：独立于方法之外的变量，不过没有 static 修饰。
• 局部变量：类的方法中的变量。

1、类变量（静态变量）

• 类变量也称为静态变量，在类中以 static 关键字声明（很少单独使用 static 声明变量。），但必须在方法之外。
• 静态变量除了被声明为常量外很少使用。
• 静态变量是指声明为 public/private，final 和 static 类型的变量。（大多数静态变量声明为 public 类型。）
• 静态变量初始化后不可改变。
• 静态变量储存在静态存储区。
• 静态变量对于类中的方法、构造方法或者语句块是可见的
• 静态变量在第一次被访问时创建，在程序结束时销毁。
• 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。

public class Employee {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    //如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。
    public static final String DEPARTMENT = "开发人员";
}

2、实例变量

• 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  当一个对象被实例化之后，每个实例变量的值就跟着确定；
• 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
• 实例变量对于类中的方法、构造方法或者语句块是可见的。
• 一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
• 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
• 实例变量可以声明在使用前或者使用后；
• 访问修饰符可以修饰实例变量；
• 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

public class Employee{
   // 这个实例变量对子类可见
   public String name;
   // 私有变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
}

3、局部变量

• 局部变量声明在方法、构造方法或者语句块中；
• 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
• 访问修饰符不能用于局部变量；
• 局部变量只在声明它的方法、构造方法或者语句块中可见；
• 局部变量是在栈上分配的。
• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

public class Test{ 
	public static void main(String [] args){
		//申明整型变量
		int score;
		//给变量赋值
		score = 98;
		//申明的同时赋值
		char gender = '男';
	}
  }

三、修饰符

Java语言提供了很多修饰符，主要分为以下两类：

1. 访问修饰符
2. 非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

1、访问控制修饰符

1. default (默认，什么也不写）
   在同一包内可见，不使用任何修饰符。
   使用对象：类、接口、变量、方法。
   接口里的变量默认声明为 public static final,而接口里的方法默认情况下访问权限为 public。

String version = "1.5.1";
boolean processOrder() {
   return true;
}

2. private
   在同一类内可见。私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
   使用对象：变量、方法。 注意：不能修饰类（外部类）

public class Logger {
	//format 变量为私有变量
   private String format;
   //其他类不能直接得到和设置该变量的值。
   //为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

3. public
   对所有类可见。
   使用对象：类、接口、变量、方法
4. protected
   对同一包内的类和所有子类可见。
   使用对象：变量、方法。
   【注】不能修饰类（外部类）。接口及接口的成员变量和成员方法不能声明为 protected

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
//子类重写了父类的 openSpeaker() 方法
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
//如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。

访问控制和继承

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

非访问修饰符

1. static 修饰符，用来修饰类方法和类变量。

• 静态变量：
  static 关键字用来声明独立于对象的静态变量。
  无论一个类实例化多少对象，它的静态变量只有一份拷贝。
  静态变量也被称为类变量。
  局部变量不能被声明为 static 变量。
• 静态方法：
  static 关键字用来声明独立于对象的静态方法。
  静态方法不能使用类的非静态变量。
  静态方法从参数列表得到数据，然后计算这些数据。

2. final 修饰符，用来修饰类、方法和变量。
   final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

• final 变量：
  final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。
  被 final 修饰的实例变量必须显式指定初始值。
  final 修饰符通常和 static 修饰符一起使用来创建类常量。
• final 方法 ：
  父类中的 final 方法可以被子类继承，但是不能被子类重写。
  声明 final 方法的主要目的是防止该方法的内容被修改。
• final 类 ：
  final 类不能被继承，没有类能够继承 final 类的任何特性。

3. abstract 修饰符，用来创建抽象类和抽象方法。

抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。
如果一个类包含抽象方法，那么该类一定要声明为抽象类
抽象类可以包含抽象方法和非抽象方法。
抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

4. synchronized

synchronized 关键字声明的方法同一时间只能被一个线程访问。 synchronized
修饰符可以应用于四个访问修饰符。

5. volatile

volatile修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

8. transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

四、运算符

运算符分成以下几组：

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

算术运算符

【重点】自加自减运算符

1. 前缀自增自减法(++a,–a):
   先进行自增或者自减运算，再进行表达式运算。
2. 后缀自增自减法(a++,a–):
   先进行表达式运算，再进行自增或者自减运算。
3. 单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;//a=a+1=6,x=2*6=12
        int y = 2*b++;//y=2*510,b=b+1=6
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10

【注】 /运算符向下取整

关系运算符

位运算符

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100=12
A | B = 0011 1101=61
A ^ B = 0011 0001=49
~A= 1100 0011=-61
A << 2=1111 0000=240
A >> 2=1111=15
A>>>2=0000 1111=15

逻辑运算符

【注】
if(a)：如果a的值为真，执行 if 后面的语句 。
if(！a)：如果a不为真，执行 if后面的语句。

【重点】短路逻辑运算符（&&）

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

&&和&的区别?

最终结果一样。
&&具有短路效果。左边是false，右边不执行。
&是无论左边是false还是true,右边都会执行

||和|的区别?

最终结果一样
||具有短路效果.左边是true,右边不执行
|是无论左边是false还是true,右边都会执行

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}
//使用短路逻辑运算符的结果为false
//a的结果为5
//首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

赋值运算符

其他运算符

条件运算符（?:）

条件运算符也被称为三元运算符。
该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

 a = 10;
 // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
 b = (a == 1) ? 20 : 30;//b=30

instanceof 运算符

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

String name = "James";
boolean result = name instanceof String; 
// 由于 name 是 String 类型，所以返回真

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      //如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
     }
}

运算符优先级

！，（）
算数运算符
关系运算符
逻辑与&&
逻辑或||
赋值运算符