面向对象（static关键字）

static作用：

A：可以修饰成员变量和成员方法

static的特点：

A:被类的所有对象共享（针对多个对象有共同的这样的成员变量值的时候，）

B：静态修饰的内容一般我们称其为：与类相关的，类成员

package day10;
/*
	定义一个人类

	姓名和年龄都是变化的，这个我能接收，因为每个人的姓名和年龄是不同的。
	但是，我们现在选取的几个人都是中国人，他们的国籍是一样的。
	一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，
	我就觉得有点浪费了。怎么办呢?
		针对多个对象有共同的这样的成员变量值的时候，
		Java就提高了一个关键字来修饰：static。
*/
class Person {
    //姓名
    String name;
    //年龄
    int age;
    //国籍
    //String country;
    static String country;

    public Person(){}

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name,int age,String country) {
        this.name = name;
        this.age = age;
        this.country = country;
    }

    public void show() {
        System.out.println("姓名："+name+",年龄："+age+",国籍："+country);
    }
}

public class LX1 {
    public static void main(String[] args) {
        //创建对象1
        Person p1 = new Person("邓丽君",16,"中国");
        p1.show();

        //创建对象2
        //Person p2 = new Person("杨幂",22,"中国");
        //p2.show();
        Person p2 = new Person("杨幂",22);
        p2.show();

        //创建对象3
        //Person p3 = new Person("凤姐",20,"中国");
        //p3.show();
        Person p3 = new Person("凤姐",20);
        p3.show();

        p3.country = "美国";
        p3.show();

        p1.show();
        p2.show();

    }
}

运行结果：

 姓名：邓丽君,年龄：16,国籍：中国
姓名：杨幂,年龄：22,国籍：中国
姓名：凤姐,年龄：20,国籍：中国
姓名：凤姐,年龄：20,国籍：美国
姓名：邓丽君,年龄：16,国籍：美国
姓名：杨幂,年龄：22,国籍：美国

/*
static关键字特点
     随着类的加载而加载
     优先于对象存在
     被类的所有对象共享
         这也是我们判断是否使用静态关键字的条件
     可以通过类名调用--也可以通过对象调用
     类明.方法名------对象名.方法名


注意事项：
static关键字注意事项
     在静态方法中是没有this关键字的
     静态方法只能访问静态的成员变量和静态的成员方法



*/

static静态关键字的注意事项：

/*
    static关键字注意事项
        A:在静态方法中是没有this关键字的
            如何理解呢?
                静态是随着类的加载而加载，this是随着对象的创建而存在。
                静态比对象先存在。
        B:静态方法只能访问静态的成员变量和静态的成员方法
                静态方法：
                    成员变量：只能访问静态变量
                    成员方法：只能访问静态成员方法
                非静态方法：
                    成员变量：可以是静态的，也可以是非静态的
                    成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
            简单记：
                静态只能访问静态。
*/

class Teacher {
	public int num = 10;
	//静态的成员变量
	public static int num2 = 20;
	//非静态的成员方法
	public void show() {
		System.out.println(num); //隐含的告诉你访问的是成员变量
		System.out.println(this.num); //明确的告诉你访问的是成员变量
		System.out.println(num2);
		
		//function();
		//function2();
	}
	
	public static void method() {
		//无法从静态上下文中引用非静态 变量 num
		//System.out.println(num);
		//静态方法只能访问静态变量不能访问非静态的成员变量
		System.out.println(num2);
		
		//无法从静态上下文中引用非静态 方法 function()
		//function();
		function2();
	}
	
	public void function() {
	
	}
	
	public static void function2() {
	
	}
}

class TeacherDemo {
	public static void main(String[] args) {
		//创建对象
		Teacher t = new Teacher();
		t.show();
		System.out.println("------------");
		t.method();
	}
}