Java 基础 static关键字与main方法的理解

关键字：static 的使用

1.static 静态的
2.static 可以用来修饰：属性、方法、代码块、内部类
3.使用static 修饰属性,静态变量（类变量）
属性 按照是否使用static修饰，又分为静态vs非静态（实例变量）
实例变量：创建了类的多个对象，每个对象都独立拥有一套类中的非静态属性
当修改一个对象的静态变量时，不会导致其他对象同样变量值的修改
静态变量：创建了类的多个对象，多个对象共享同一个静态变量，
当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，时修改的
static 修饰属性的其他说明
静态变量随着类的加载而加载；可以通过类名.静态变量名去调
静态变量的加载要早于对象的创建
静态变量可以通过类名.静态变量名去调
由于类加载一次，则静态变量在内存中也只有一份
          类变量    实例变量
类          yes        no
对象       yes        yes
静态属性的示例： System.out；Math.IP

4.使用static 修饰方法
1.随着类的加载而加载，可以通过“类.方法”的方式进行调用
        类方法    实例方法
类          yes        no
对象       yes        yes
2静态方法，只能调静态方法或者静态属性
非静态的方法可以调用静态方法和静态属性也可以调非静态方法和非静态属性
static的注意点
在静态方法内，不能用this关键字、和super关键字
关于静态属性和方法的使用，从生命周期的角度去理解
开发中如果确定一个属性是否声明static的；类中常量也常常声明为static的
属性是可以被多个对象共享的，不会随着对象的不同而不同的
开发中如何确定一个方法是否声明为static的
操作静态属性的方法，设置成静态方法
工具类方法，习惯声明为static的方法

测试

public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name="姚明";
        c1.age= 40;
        c1.nation="中国";
        Chinese c2= new Chinese();
        c2.name = "马龙";
        c2.age = 30;
        c2.nation= "CHINA";//
        System.out.println(c2.nation+"	"+c1.nation);
        //通过类调用静态方法
        Chinese.show();
    }
}

class  Chinese{
    String name;
    int age;
    static  String nation;
    public void eat(){
        System.out.println("中国人吃中餐");
    }
    public static  void  show(){
        System.out.println("我是一个中国人");
        //在静态方法里不能调用非静态方法
        //eat();
        //可以调用静态的方法
        walk();
    }

    public void  info (){
        System.out.println("name:"+name+",age:"+age);
    }
    public static void walk(){
        System.out.println("走路");
    }

}

　　示例2

package com.chenxi.java;

public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle();
        Circle c3 = new Circle(4.0);
        System.out.println(c1.getId());
        System.out.println(c2.getId());
        System.out.println(Circle.getTotal());
        System.out.println(c3.findArea());
        System.out.println(Circle.getTotal());
    }
}
class  Circle{
    public Circle(){
        id = init++;//先赋值后加加
        total++;
    }
    public Circle(double radius){
        this();
        this.radius=radius;
    }
    private double radius;//半经
    private int id;
 //   private int total;
    private  static  int total;//创建园的个数
    private static  int init= 1001;//静态属性，被所以对象共享
    public double findArea(){
        return 3.14*radius*radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public static int getTotal() {
        return total;
    }

    public static void setTotal(int total) {
        Circle.total = total;
    }

    public static int getInit() {
        return init;
    }

    public static void setInit(int init) {
        Circle.init = init;
    }
}



测试结果
1001
1002
3
50.24
3

　　单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱。”套路”

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构

器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，构造

静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

饿汉式单例模式实现

示例

package com.chenxi.java1;
/*
单例的设计模式
1.所谓的单例设计模式，就是采取一定的方法保证整个软件系统中，对某个类只有
一个对象实例
2.如何实现

 */
public class SinglelonTest {
    public static void main(String[] args) {


        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1==bank2);
    }


}
//饿汉式单例模式
class Bank{
    //私有化类的构造器
    private Bank(){

    }
    //内部类创建对象；要求此对象也是静态的
    private static Bank instance = new Bank();
    //提供一个公共的静态方法
    public static Bank getInstance(){
        return instance;
    }

}
测试
true

　　饿汉式模式示例

package com.chenxi.java1;
/*
单例模式的懒汉式实现
区分饿汉式和懒汉式
饿汉式：
坏处初始化就创建对象；对象加载时间过长
优势：饿汉式是线程安全的

懒汉式：好处延迟，对象的创建；前期节省内存空间
目前写法不安全---->多线程内容修改

 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1==order2);
    }
}
class Order{
    //私有化类的构造器
    private Order(){

    }
    //声明当前类的对象没有初始化,
    //声明为static，用的时候造
    private static Order instance = null;//懒
    //声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if (instance==null) {
            instance = new Order();
        }
        return instance;
    }
}
测试结果
true

单例模式的优点：

由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方

式来解决

单例(Singleton)设计模式-应用场景

 

网站的计数器，一般也是单例模式实现，否则难以同步。

应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。

项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。

Application 也是单例的典型应用

 Windows的Task Manager (任务管理器)就是很典型的单例模式

Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

main 方法的理解

man（）方法的使用说明

1.main()方法的程序入口

2.main()方法也是普通的静态方法

3.man()方法可以作为与控制台交互的方式（之前使用Scanner）

示例

public class MainTest {
    public static void main(String[] args) {
      Main.main(new String[100]);
    }
}
class Main {
    public  static void main(String[] args){
        args= new  String[1000];
        for (int i = 0 ; i<args.length;i++){
            args[i] = "args_"+i;
            System.out.println(args[i]);
        }
    }
}