当前位置：首页 > news >正文

类变量和类方法main方法代码块单例设计模式final关键字抽象类接口接口多态的特性

news 2025/10/29 16:26:53

类变量

package Static_;public class ChildGame {public static void main(String[] args) {//定义一个变量 count 统计有多少小孩加入了游戏Child child1 = new Child("白骨精");child1.join();child1.count++;Child child2 = new Child("白骨精");child2.join();child2.count++;Child child3 = new Child("白骨精");child3.join();child3.count++;System.out.println("共有 " + child1.count + " 小孩加入了游戏...");System.out.println("共有 " + child2.count + " 小孩加入了游戏...");System.out.println("共有 " + child3.count + " 小孩加入了游戏...");}
}class Child{public static int count = 0;private String name;public Child(String name){this.name = name;}public void join(){System.out.println(name + " 加入了游戏... ");}
}

不管static变量在哪里

1.静态变量是对象共享的，因此不影响使用

2.static类变量，在类加载的时候就生成了

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是同一个变量，同样任何一个该类的对象去修改它时，修改的也都是同一个变量。

如何定义类变量

定义语法：

访问修饰符 static 数据类型变量名；

static 访问修饰符数据类型变量名；

如何访问类变量

类名.类变量名【推荐】

或者对象名.类变量名【静态变量的访问修饰符的访问权限和范围和普通属性是一样的】

package Static_;public class VisitStatic_ {public static void main(String[] args) {//类变量是随着类的加载而创建，所以即使没有创建对象实例也能访问System.out.println(A.name);//类名.类变量名A a = new A();System.out.println(a.name);//对象名。类变量名}
}class A {public static String name = "天下第一大帅";
}

package Static_;public class StaticMethod {public static void main(String[] args) {Stu jack = new Stu("jack");jack.payFee(100);Stu mary = new Stu("mary");mary.payFee(100);Stu.showFee();}
}
class Stu{private String name;private static double fee = 0;public Stu(String name) {this.name = name;}//1.当方法使用static修饰后，该方法就是静态方法//2.静态方法就可以访问静态属性/变量public static void payFee(double fee){Stu.fee += fee;}public static void showFee(){System.out.println("总学费：" + Stu.fee);}
}

main方法

可在此处传参

代码块

3个构造器重载

（1）假如三个构造器都有相同的语句

（2）代码看起来会很冗余

（3）这时我们可以把相同的语句放进代码块中

（4）这样当我们不管调用哪个构造器，都会创建对象，都会先调用代码块的内容

（5）代码块的调用顺序优先于构造器

单例设计模式

package SingleTon_;public class SingleTon01 {public static void main(String[] args) {//    GirlFriend xh = new GirlFriend("小红");//    GirlFriend xh1 = new GirlFriend("小红2");  私有的对象只能在本类使用//通过方法可以获取对象GirlFriend instance = GirlFriend.getInstance();System.out.println(instance);GirlFriend instance1 = GirlFriend.getInstance();System.out.println(instance1);System.out.println(instance == instance1);System.out.println(GirlFriend.n1);}
}
class GirlFriend{private String name;public static int n1 = 100;//为了能在静态方法中，返回gf对象，需要将其修饰为static//对象，通常是重量级对象，饿汉模式可能会造成创建了对象，但是没有使用private static GirlFriend gf = new GirlFriend(("小红红"));//如何保障我们只能创建一个 Girlfriend 对象//步骤：[单利模式-饿汉式]//1.将构造器私有化（防止在类的外部创建）//2.在类的内部直接创建（该对象是static）//3.提供一个公有的static方法，返回gf对象private GirlFriend(String name){this.name = name;}public static GirlFriend getInstance(){return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
}

懒汉式

package SingleTon_;
/*
* 演示懒汉式的单例模式
* */public class SingleTon02 {public static void main(String[] args) {System.out.println(Cat.n1);Cat instance = Cat.getInstance();System.out.println(instance);Cat instance1 = Cat.getInstance();System.out.println(instance1);}
}
//希望在程序运行过程中，只创建一个Cat对象
class Cat{private String name;public static int n1 = 999;private static Cat cat;//步骤// 1.仍然构造器私有化// 2.定义一个static静态属性对象// 3.提供一个public的static方法，可以返回一个Cat对象// 4.懒汉式，只有当用户使用getInstance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象// 从而保证了单例private Cat(String name) {System.out.println("构造器被调用");this.name = name;}public static Cat getInstance(){if (cat == null){cat = new Cat("大可爱");}return cat;}@Overridepublic String toString() {return "Cat{" +"name='" + name + '\'' +'}';}
}

final关键字

package final_;public class final01 {public static void main(String[] args) {E e = new E();
//        e.TAX_RATE = 0.09;}
}
final class A{}//class B extends A{}class C{public final void hi(){}
}
class D extends C{
//    @Override
//    public void hi() {
//        System.out.println("重写了hi（）方法。。。");
//    }
}
class E{public final double TAX_RATE = 0.08;
}class F{public void cry(){final double NUM = 0.01;
//      NUM = 0.9;System.out.println("NUM=" + NUM);}
}

package final_;public class FinalExercise01 {public static void main(String[] args) {AA aa = new AA(1);System.out.println(aa.calAre());}
}
class AA{private double radius;private final double PI;// = 3.14;public AA(double radius) {this.radius = radius;//PI = 3.14;}{PI = 3.14;}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}public double getPI() {return PI;}public double calAre(){return PI * radius * radius;}
}

抽象类

package abstract_.abstract01;abstract public class Employee {public abstract void work();private String name;private int id;private double salary;public Employee(String name, int id, double salary) {this.name = name;this.id = id;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}
}

package abstract_.abstract01;public class commonEmployee extends Employee{public commonEmployee(String name, int id, double salary) {super(name, id, salary);}@Overridepublic void work() {System.out.println("名字" + getName() + "正在工作");}
}

package abstract_.abstract01;public class manager extends Employee{private double bonus;public manager(String name, int id, double salary, double bonus) {super(name, id, salary);this.bonus = bonus;}@Overridepublic void work() {System.out.println("名字" + getName() + "正在工作中。。。");}
}

package abstract_.abstract01;public class abstractexercise01 {public static void main(String[] args) {commonEmployee tom = new commonEmployee("tom", 123, 12333);tom.work();manager jif = new manager("jif", 1234, 1234555, 432123);jif.work();}
}

接口

接口多态的特性

package abstract_.abstract01;public class InterfacePolyPass {public static void main(String[] args) {//接口类型的变量可以指向，实现了该接口的类的对象实例IG ig = new Teacher();//如果IG 继承了 IH接口，而Teacher 类实现了 IG接口//那么，实际上就相当于 Teacher 类也实现了 IH接口//这就是所谓的 接口多态传递现象IH ih = new Teacher();}
}
interface IH{void hi();
}
interface IG extends IH{
}
class Teacher implements IG{@Overridepublic void hi() {System.out.println("你好！");}
}