一、数据类型
1、基本数据【8种】值传递
（1）数字类型【6种】
- 整数【4种】补码表示
byte：8位，有符号,- 27 ~27-1
short：16位
int：32位
long：64位
byte a=100;
short b=100;
int c=100;
long d=100l;//尾巴l莫忘
- 浮点数【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、访问控制修饰符
- default (默认，什么也不写）
在同一包内可见，不使用任何修饰符。
使用对象：类、接口、变量、方法。
接口里的变量默认声明为 public static final,而接口里的方法默认情况下访问权限为 public。
String version = "1.5.1";
boolean processOrder() {
return true;
}
- 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;
}
}
- public
对所有类可见。
使用对象：类、接口、变量、方法 - 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 的方法，不能够被继承。
非访问修饰符
- static 修饰符，用来修饰类方法和类变量。
- 静态变量：
static 关键字用来声明独立于对象的静态变量。
无论一个类实例化多少对象，它的静态变量只有一份拷贝。
静态变量也被称为类变量。
局部变量不能被声明为 static 变量。- 静态方法：
static 关键字用来声明独立于对象的静态方法。
静态方法不能使用类的非静态变量。
静态方法从参数列表得到数据，然后计算这些数据。
- final 修饰符，用来修饰类、方法和变量。
final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
- final 变量：
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。
被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。- final 方法 ：
父类中的 final 方法可以被子类继承，但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。- final 类 ：
final 类不能被继承，没有类能够继承 final 类的任何特性。
- abstract 修饰符，用来创建抽象类和抽象方法。
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。
如果一个类包含抽象方法，那么该类一定要声明为抽象类
抽象类可以包含抽象方法和非抽象方法。
抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
.........
}
}
- synchronized
synchronized 关键字声明的方法同一时间只能被一个线程访问。 synchronized
修饰符可以应用于四个访问修饰符。
- volatile
volatile修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
- transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
public transient int limit = 55; // 不会持久化
public int b; // 持久化
四、运算符
运算符分成以下几组：
- 算术运算符
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
算术运算符
【重点】自加自减运算符
- 前缀自增自减法(++a,–a):
先进行自增或者自减运算，再进行表达式运算。- 后缀自增自减法(a++,a–):
先进行表达式运算，再进行自增或者自减运算。- 单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。
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。
}
}
运算符优先级
！，（）
算数运算符
关系运算符
逻辑与&&
逻辑或||
赋值运算符
扫一扫
921
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
