Java基础知识 09（static关键字，Math类，面向对象—代码块）

最新推荐文章于 2022-01-08 00:53:50 发布

骑着蜗牛行天下

最新推荐文章于 2022-01-08 00:53:50 发布

阅读量157

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_45447369/article/details/105548908

版权

Java基础专栏收录该内容

42 篇文章 0 订阅

订阅专栏

Java基础知识 09

static关键字

static：静态的，可以修饰成员变量，也可以修饰成员方法，static修饰成员变量，此变量就为一个共享变量，会被该类的所有对象所共享。
static关键字特点：（1）随着类的加载而加载。（2）优先于对象而存在。（3）被类的所有对象所共享。
如果某个成员变量是被所有对象共享的，那么他就应该被定义成静态的。
对于静态所修饰的成员，推荐使用 类名 调用。被静态修饰的成员属于类，推荐使用类名直接调用。

案例程序分析1：
public class Person {
    String name;
    //static:静态的 可以修饰成员变量也可以修饰成员方法
    //static修饰成员变量，此变量就为一个共享变量，会被该类的 所有对象所共享。
    public static String guoji="中国";
}
public class test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name="张三";
        //被静态修饰的成员属于类，推荐使用类名直接调用。无需new对象来调用。当然对象可以调用，但是不推荐。
        Person.guoji="美国";
        Person p2 = new Person();
        p2.name="李四";

        Person p3 = new Person();
        p3.name="王五";
        //被静态修饰的成员属于类，推荐使用类名直接调用。无需new对象来调用。当然对象可以调用，但是不推荐。
        Person.guoji="英国";
        System.out.println(p1.name);//张三
        System.out.println(p1.guoji);英国
        System.out.println("-----------------");
        System.out.println(p2.name);//李四
        System.out.println(p2.guoji);//英国
        System.out.println("-----------------");
        System.out.println(p3.name);//王五
        System.out.println(p3.guoji);//英国
    }
}

static内存图：
在这里插入图片描述

静态的方法中，访问不到非静态的数据，静态方法中只能访问静态修饰的成员。
静态修饰的成员，随着类的加载而加载，优先于对象存在，先存在访问不到后存在的。
非静态的方法中，既能访问静态的，也能访问非静态的。
静态方法中，只能访问静态变量，也只能调用静态方法。
静态方法中不能出现this，this代表一个对象，对象是后来才有的，先有的不能访问后有的。
主方法是静态修饰的，主方法中可以直接调用静态方法。
主类，只是提供程序的入口，一般不会在主类中提供成员变量和成员方法。

案例程序分析2：
public class test {
}
class student{
    String name="张三";
    public static int age=35;
    //非静态方法
    public void teacher(){
        System.out.println(name);
        System.out.println(age);
    }
    //静态方法
    public static void doctor(){
        System.out.println(age);
        //System.out.println(name);
    }
    //非静态方法调用成员方法
    public void siji(){
        System.out.println("司机");
        this.teacher();
        doctor();
    }
    public static void hushi(){
        System.out.println("护士");
        //teacher();
        doctor();
        //静态方法中不能加this
        //this.teacher();
    }
}

成员变量和静态变量的区别：
成员变量属于对象，随着对象的创建而产生，随着对象的销毁而销毁，成员变量，也叫实例变量，对象变量。
静态变量属于类，随着类的加载而产生的，随着类的销毁而销毁，静态变量也叫做类变量。
成员变量存储在堆内存，静态变量存储在方法区的静态区；成员变量通过对象来调用，静态变量通过类名来调用，当然静态变量也可以通过对象来调用，但是不推荐啊。

案例程序分析3：
public class test2 {
    //成员变量
    String name="张三";
    static double num=20;

    public static void main(String[] args) {
        test2.student();        //1.学生
        student();			//2.学生
        //test2.teacher();
        test2 t = new test2();//new新对象
        t.teacher();        //3.老师
        System.out.println(num);  //4.20.0
        System.out.println(t.name);   //5.张三
    }
    public static void student(){
        System.out.println("学生");
    }
    public void teacher(){
        System.out.println("老师");
    }
}

Math类

Math:是一个关于数学运算方面的类，它的成员变量和成员方法，全部都是static修饰的，使用类名可以直接调用。
//私有化构造，外界不能再new对象
Math.random();//随机生成一个小数，范围大于小于。
	for(int i=0;i<100;i++){
        double num=math.random();
        System.out.println(num);
	}

案例程序分析4：
package org.westos.demo2;

import java.util.Scanner;

public class GuessNumberGame {
    public static void main(String[] args) {
        int num=(int)((Math.random()*100)+1);
        //只给用户5次机会，每次输入完还得显示剩余次数。
        //5次机会用完直接关闭。
        Scanner sc = new Scanner(System.in);
        int j=5;
        while(true){
                System.out.println("请猜一个整数，1---100");
                System.out.println("还剩余"+j+"次机会");
                j--;
                int unum = sc.nextInt();
                if(unum>num){
                    System.out.println("猜大了。");
                }else if(unum<num){
                    System.out.println("猜小了。");
                }else{
                    System.out.println("恭喜你，猜对了！！！");
                    break;
                }
                if(j==0){
                    System.out.println("对不起，您的次数已用完！");
                    break;
                }
            }
        }
    }

上节课this关键字，构造方法例题回顾：
/*A:案例演示
    需求：定义一个员工(Employee)类,自己分析出几个成员，
    然后给出成员变量，构造方法，getXxx()/setXxx()方法，
    以及一个显示所有成员信息的方法。并测试。*/
public class Employee {
    /*A:案例演示
    需求：定义一个员工(Employee)类,自己分析出几个成员，
    然后给出成员变量，构造方法，getXxx()/setXxx()方法，
    以及一个显示所有成员信息的方法。并测试。*/
    private String name;
    private int JobNumber;
    private double InCome;
    public Employee(){
    }
    public Employee(String name,int JobNumber,double InCome){
        this.name=name;
        this.JobNumber=JobNumber;
        this.InCome=InCome;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setJobNumber(int JobNumber){
        this.JobNumber=JobNumber;
    }
    public void setInCome(double InCome){
        this.InCome=InCome;
    }
    public String getName() {
        return name;
    }
    public  int getJobNumber() {
        return JobNumber;
    }
    public double getInCome() {
        return InCome;
    }
}
---------------------------------------------
public class test {
    /*A:案例演示
    需求：定义一个员工(Employee)类,自己分析出几个成员，
    然后给出成员变量，构造方法，getXxx()/setXxx()方法，
    以及一个显示所有成员信息的方法。并测试。*/
    public static void main(String[] args) {
        Employee employee = new Employee();
        employee.setName("张三");
        employee.setJobNumber(152027);
        employee.setInCome(8888.888);
        String name = employee.getName();
        int JobNumber = employee.getJobNumber();
        double InCome = employee.getInCome();
        System.out.println(name);
        System.out.println(JobNumber);
        System.out.println(InCome);
        System.out.println("----------------------");
        Employee employee1 = new Employee("李四", 152028, 6666.666);
        String name1 = employee1.getName();
        int JobNumber1 = employee1.getJobNumber();
        double InCome1 = employee1.getInCome();
        System.out.println(name1);
        System.out.println(JobNumber1);
        System.out.println(InCome1);
    }
}

面向对象—代码块

代码块：就是被一对{}所括起来的内容。
代码块根据定义位置的不同可以分为：局部代码块，构造代码块，静态代码块，同步代码块（后面讲）。
局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率。
构造代码块：我们在创建对象时，就会使用构造代码块，而且构造代码块是优先于构造方法执行的。
		  每次创建对象，构造代码块都会执行。
静态代码块：静态修饰的，是随着类的加载而加载。
		  用于给类进行初始化，在虚拟机加载类的时候就会加载执行，并且只执行一次。
静态代码块是自动执行的，而静态方法是被调用的时候才执行的。

案例程序分析5：
public class student {
    public student(){
        System.out.println("构造方法执行了");
    }
    //跟构造方法同级的构造代码块
    {
        System.out.println("构造代码块执行了");
    }
    //静态代码块
    //静态修饰的，是随着类的加载而加载  Student.class
    //******用于给类进行初始化，在加载的时候就执行，并且只执行一次******
    static {
        System.out.println("我们在类加载的时候，就可以在静态代码块里面，编写代码，做一些准备工作");
        System.out.println("静态代码块");
    }
}
package org.westos.demo;

import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {
        //局部代码块
        int num=20;
        {
            int num1=200;
            Scanner scanner = new Scanner(System.in);
            System.out.println("局部代码块");
            System.out.println(num1);
        }
        //构造代码块
        System.out.println("--------------------------");
        student student = new student();
        student student1 = new student();
    }
}

上面这段代码涉及到一个构造方法，构造代码块，静态代码块的执行顺序问题：
		静态代码块 > 构造代码块 > 构造方法

案例程序分析6：
class Student {
    static {
        System.out.println("Student 静态代码块"); //3 只执行一次
    }
    {
        System.out.println("Student 构造代码块"); //4 6
    }

    public Student() {
        System.out.println("Student 构造方法"); //5 7
    }
}
class StudentDemo {
    static {
        System.out.println("StudentDemo的静态代码块"); //1
    }
    public static void main(String[] args) {
        System.out.println("我是main方法"); //2
        Student s1 = new Student();
        Student s2 = new Student();
    }
}