1.静态变量
public class MerchandiseV2WithStaticVariable {
public String name;
public String id;
public int count;
public double soldPrice;
public double purchasePrice;
// >> TODO 静态变量使用 static 修饰符
// >> TODO 静态变量如果不赋值,Java也会给它赋以其类型的初始值
// >> TODO 静态变量一般使用全大写字母加下划线分割。这是一个习惯用法
// >> TODO 所有的代码都可以使用静态变量,只要根据防范控制符的规范,这个静态变量对其可见即可
// TODO 比如 public 的静态变量,所有的代码都可以使用它
public static double DISCOUNT_FOR_VIP = 0.95;
// TODO 但是如果没有public修饰符,只能当前包的代码能使用它
static int STATIC_VARIABLE_CURR_PACKAGE_ONLY = 100;
1.静态变量和成员变量不一样,成员变量的值在不同的对象里面可以不一样,但是静态变量的值在所有对象里都一样,如果一个对象改变了静态变量的值,那么其他对象引用该静态变量的值也会随着发生变化。
2.静态变量和成员变量不一样的是,静态变量不需要随着对象的创建才创建出来,我们可以直接用类名就引用它;
静态变量一个类一个
成员变量一个实例一个
使用同一个包里不同类里的静态变量:
// >> TODO 使用别的类的静态变量的时候,需要使用完整形态:类名.静态变量名字
MerchandiseV2WithStaticVariable.DISCOUNT_FOR_VIP = 0.5;
bigProfit.describe();
double cost2 = bigProfit.buy(10, true);
System.out.println("VIP 购买10个" + bigProfit.getName() + "的花费为" + cost2);
// >> TODO 静态变量在整个Java程序中只有一个(对比实例变量,是每个实例有一份
// TODO 所以静态变量一旦变化,所有使用这个静态变量的地方的值都会变
MerchandiseV2WithStaticVariable m0 = littleSuperMarket.getMerchandiseOf(0);
使用不同包里的静态变量
import com.geekbang.supermarket.MerchandiseV2WithStaticVariable;
import static com.geekbang.supermarket.MerchandiseV2WithStaticVariable.*;
public class MerchandiseV2DescAppMain {
public static void main(String[] args) {
MerchandiseV2WithStaticVariable merchandise = new MerchandiseV2WithStaticVariable
("书桌", "DESK9527", 40, 999.9, 500);
merchandise.describe();
// >> TODO 使用import static来引入一个静态变量,就可以直接用静态变量名访问了
// TODO import static也可以使用通配符*来引入一个类里所有静态变量
System.out.println(DISCOUNT_FOR_VIP);
}
}
也就是说,同一包里就用类名.静态变量
不同包里就用包名.类名.静态变量
综上,其实无论在同一个包里还是不同包里,都可以使用import的方法先给它导入进来,然后就可以直接使用静态变量了;
2.静态方法
静态方法(也叫类方法):只能使用参数和静态变量,换言之,就是就是没有this自引用(变量引用和方法引用)的方法;
静态方法的定义和调用:
定义:
public class MerchandiseV2 {
public String name;
public String id;
public int count;
public double soldPrice;
public double purchasePrice;
// >> TODO 静态变量使用 static 修饰符
public static double DISCOUNT_FOR_VIP = 0.95;
// >> TODO 静态方法使用static修饰符。
// 静态方法的方法名没有约定俗称全大写
public static double getVIPDiscount() {
// >> TODO 静态方法可以访问静态变量,包括自己类的静态变量和在访问控制符允许的别的类的静态变量
return DISCOUNT_FOR_VIP;
}
// >> TODO 除了没有this,静态方法的定义和成员方法一样,也有方法名,返回值和参数
// >> TODO 静态方法没有this自引用,它不属于某个实例,调用的时候也无需引用,直接用类名调用,所以它也不能直接访问成员变量
// >> TODO 当然在静态方法里面,也可以自己创建对象,或者通过参数,获得对象的引用,进而调用方法和访问成员变量
// >> TODO 静态方法只是没有this自引用的方法而已。
public static double getDiscountOnDiscount(LittleSuperMarket littleSuperMarket) {
double activityDiscount = littleSuperMarket.activityDiscount;
return DISCOUNT_FOR_VIP * activityDiscount;
}
使用
import com.geekbang.supermarket.MerchandiseV2;
import static com.geekbang.supermarket.MerchandiseV2.getVIPDiscount;
public class MerchandiseV2DescAppMain {
public static void main(String[] args) {
MerchandiseV2 merchandise = new MerchandiseV2
("书桌", "DESK9527", 40, 999.9, 500);
merchandise.describe();
// >> TODO 使用import static来引入一个静态方法,就可以直接用静态变量名访问了
// TODO import static也可以使用通配符*来引入一个类里所有静态变量
System.out.println(getVIPDiscount());
}
}
静态方法的重载
public class DiscountMgr {
public static double BASE_DISCOUNT = 0.99;
public static double VIP_DISCOUNT = 0.85;
public static double SVIP_DISCOUNT = 0.75;
// >> TODO 静态方法的重载也是一样的,方法签名不同即可:方法名+参数类型
// >> TODO 判断调用哪个方法,也是根据调用时参数匹配决定的。
public static double getDiscount() {
return BASE_DISCOUNT;
}
public static double getDiscount(boolean isVIP) {
// TODO >> 这节课这么无聊,我们顺带学一个三元操作符吧。
// TODO 三元操作符的返回类型就是冒号两边的类型,两边的类型要和等号左边的变量类型兼容
// double abc = true ? "" : 0;
double svipDiscount = (isVIP ? VIP_DISCOUNT : 1);
return getDiscount() * svipDiscount;
}
public static double getDiscount(int svipLevel) {
double ret = getDiscount() * VIP_DISCOUNT;
for (int i = 0; i < svipLevel; i++) {
ret *= SVIP_DISCOUNT;
}
return ret;
}
// 这节课这么无聊,我们顺带看几个不是那么正经的getDiscount吧
// >> TODO 返回值不算是方法签名,重载的方法可以有完全不同的返回值类型
public static void getDiscount(String s) {
System.out.println(s);
}
public static int getDiscount(int a, int b) {
return a > b ? a : b;
}
public static boolean getDiscount(int a, int b, int c) {
return a > b && b > c;
}
public static String getDiscount(long abc) {
return "" + abc;
}
public static void main(String[] args) {
getDiscount(1, 2);
}
}
静态代码块
public class DiscountMgr {
public static void main(String[] args) {
System.out.println("最终main 方法中使用的SVIP_DISCOUNT是" + SVIP_DISCOUNT);
}
public static double BASE_DISCOUNT;
public static double VIP_DISCOUNT;
// >> TODO 使用某个静态变量的代码块必须在静态变量后面
// >> TODO (但是仅仅赋值没有限制,很妖的语法哈,有些语法就应该在学会的第一时间忘掉它)
public static double SVIP_DISCOUNT;
static {
BASE_DISCOUNT = 0.99;
VIP_DISCOUNT = 0.85;
SVIP_DISCOUNT = 0.75;
// >> TODO 静态代码块里当然可以有任意的合法代码
System.out.println("静态代码块1里的SVIP_DISCOUNT" + SVIP_DISCOUNT);
// >> TODO 这段代码在哪个方法中呢?<clinit>,即class init。会在每个class初始化的时候被调用一次
// SVIP_DISCOUNT = 9/0;
}
// >> TODO 其实给静态变量赋值也是放在代码块里的,static代码块可以有多个,是从上向下顺序执行的。
// TODO 可以认为这些代码都被组织到了一个clinit方法里
// public static double WHERE_AM_I = 9/0;
// public static double SVIP_DISCOUNT;
static {
SVIP_DISCOUNT = 0.1;
System.out.println("静态代码块2里的SVIP_DISCOUNT" + SVIP_DISCOUNT);
}
}
我们发现,静态代码块并不在我们的方法体里面,那它在哪儿呢,事实上,它存在于java的一个初始化方法里面;
3.访问修饰符(public,private)
// >> TODO 类,静态方法,静态变量,成员变量,构造方法,成员方法都可以使用访问修饰符
public class MerchandiseV2 {
// >> TODO 成员变量应该都声明为private
// >> TODO 如果要读写这些成员变量,最好使用get set方法,这些方法应该是public的
// >> TODO 这样做的好处是,如果有需要,可以通过代码,检查每个属性值是否合法。
private String name;
private String id;
private int count;
private double soldPrice;
private double purchasePrice;
private NonPublicClassCanUseAnyName nonPublicClassCanUseAnyName;
public static double DISCOUNT = 0.1;
// >> TODO 构造方法如果是private的,那么就只有当前的类可以调用这个构造方法
public MerchandiseV2(String name, String id, int count, double soldPrice, double purchasePrice) {
this.name = name;
this.id = id;
this.count = count;
this.soldPrice = soldPrice;
this.purchasePrice = purchasePrice;
// soldPrice = 9/0;
}
// >> TODO 有些时候,会把所有的构造方法都定义成private的,然后使用静态方法调用构造方法
// >> TODO 同样的,这样的好处是可以通过代码,检查每个属性值是否合法。
public static MerchandiseV2 createMerchandise(String name, String id, int count,
double soldPrice, double purchasePrice) {
if (soldPrice < 0 || purchasePrice < 0) {
return null;
}
return new MerchandiseV2(name, id, count, soldPrice, purchasePrice);
}
public MerchandiseV2(String name, String id, int count, double soldPrice) {
this(name, id, count, soldPrice, soldPrice * 0.8);
}
public MerchandiseV2() {
this("无名", "000", 0, 1, 1.1);
}
// >> TODO public的方法类似一种约定,既然外面的代码可以使用,就意味着不能乱改。比如签名不能改之类的
public void describe() {
System.out.println("商品名字叫做" + name + ",id是" + id + "。 商品售价是" + soldPrice
+ "。商品进价是" + purchasePrice + "。商品库存量是" + count +
"。销售一个的毛利润是" + (soldPrice - purchasePrice));
freeStyle();
}
// >> TODO 对于private的方法,因为类外面掉不到,所以无论怎么改,也不会影响(直接影响)类外面的代码
private void freeStyle() {
}
继承里的静态方法