面向对象（四）：[状态修饰词(static关键字、final关键字)，封装]

static即为静态的意思。它可以修饰类的成员变量，成员方法，代码块，但不能修饰局部变量。

静态变量：被static修饰的成员变量，该变量称为静态变量，可以被所有实例所共享。

静态方法：被static修饰的方法，该方法称为静态方法。

                 Java中的程序入口就是一个静态方法。

public static void main(String[] args){
            方法体
}

访问静态变量：类名.变量名(推荐)

package day11;

class Student{
    static String schoolName;//声明静态变量schoolName
}

public class Demo1 {

    public static void main(String[] args) {
        Student stu1=new Student();//创建第一个学生对象
        Student stu2=new Student();//创建第二个学生对象
        Student.schoolName="清华大学";//给静态变量赋值
        //输出两个学生对象的信息
        System.out.println("我是"+stu1.schoolName+"的学生");
        System.out.println("我是"+stu2.schoolName+"的学生");
    }
}

 访问静态方法：1类名.方法名(推荐)      2实例对象名.方法名

package day11;
class Person{
    public static void say(){
        System.out.println("Hello");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        //1用"类名.方法名"的形式调用静态方法
        Person.say();
        //2用“实例化对象.方法名”调用静态方法
        Person p1=new Person();
        p1.say();

    }
}

由此可见，静态方法不需要创建对象就能通过类名调用。也可以通过实例化对象的方式调用静态方法。 

注意：静态方法不可以调用非静态方法

          静态方法可以调用静态方法

          静态方法不可以调用非静态变量

          静态方法可以访问静态变量

          非静态方法中有隐式的this传递,静态方法中是没有的

​
package day11;

public class Demo {
    public static void main(String[] args) {
        Eoo eoo=new Eoo();
        eoo.test01();
    }
}
class Eoo{
    static int a=10;
    int b=20;
    public static void  staticTest01(){
        //静态方法中没有this的概念
        // System.out.println(this.b);静态方法中不可以使用this,
        //b  test01()  test02()非静态资源,只能通过对象来访问,
        //所以在静态方法中无法直接访问非静态资源
    }

    public void test01(){
        //非静态方法中有隐式this传递
        System.out.println(b);//==System.out.println(this.b);
        System.out.println(this.b);
        test02();//==this.test02();
        this.test02();
    }
    public void test02(){
        System.out.println("大胆！");
    }
}

​

非静态资源只能通过对象来访问

总结：1.非静态方法可以直接访问静态资源和非静态资源

          2.静态方法只能直接访问静态资源

静态代码块：在Java中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。

静态代码块格式：

static{

    若干行代码
}

注意：当类被加载时（类何时被加载:创建本类对象或者子类对象时），静态代码块会执行，由于类只加载一次，因此静态代码块也只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化。

package day11;

class A{
    static {
        System.out.println("执行了Person类中的静态代码块");
    }
}
public class Demo3 {
    static {
        System.out.println("执行了Demo3中的静态代码块");
    }

    public static void main(String[] args) {
        //实例化两个A对象
        A a1=new A();
        A a2=new A();
    }
}

 从运行结果可以看出，程序中的两段静态代码块都执行了。Java虚拟机首先会加载类Demo3，在加载类的同时就会执行该类的静态代码块，紧接着就会调用main（）方法。在main（）方法中创建了两个A对象，但在两次实例化对象过程中，静态代码块中的内容只输出了一次，这就说明静态代码块在类第一次使用时才会被加载，并且只会加载一次。

static（ 静态关键字）： 让所有对象公用，而且不依赖对象，可以直接通过类名调用，会先被                                             加载进来        
            1.static修饰的属性和方法 优先于对象存在，不依赖对象，可以直接通过类名调用
            2.static修饰的属性和方法，只会被加载一次
            3.static修饰的属性和方法，只有一份，会被所有对象共用。
            4.static修饰的属性和方法，优先加载。
            5. static 修饰的内容在类加载(使用类)的时候，会优先加载
            6. 父类的东西要优先于子类的加载
            7. static静态的东西优先于对象存在。所以，建议调用static的东西用类名直接调用
            8. 创建对象的前提，要先加载类——> 静态的资源——>非静态资源——>调用构造器创                    建对象
使用static关键字需要注意的问题:
1. 在static 修饰的方法（静态方法）中，不能直接访问非static（非静态） 的属性或者方法; 需要访问（调用）非static（非静态）的，需要通 过对象访问（调用）
2. static修饰的方法和属性，可以在静态的方法和非静态的方法中都可以直接调用

3. static修饰的方法和属性，既可以通过类名调用（推荐），也可以通过对象调用
4.静态方法中可以直接调用静态的属性和方法
5.static 修饰的属性，可以直接通过类名调用(推荐)

非静态方法（没有用static修饰的方法）：
非静态的方法中可以直接调用非静态的属性或者方法
在非静态的方法中可以直接调用静态的方法和属性

static修饰的内容，会被所有的对象共享，只有一份。
static 修饰的内容，无论创建多少个对象，只会加载一次（所有对象都共用这一个）。
非static的内容，每次创建对象时，都会重新加载一次。

二（状态修饰词final）

final关键字：可用于修饰类，变量和方法，它有“不可更改”或“最终”的含义，因此被final修饰的的类，变量和方法有以下特性：

1. final修饰的类不能被继承。
2. final修饰的方法不能被子类重写。
3. final修饰的变量（成员变量和局部变量）是常量，只能被赋值一次。

final关键字修饰类：

Java中的类被final关键字修饰后，该类不能被继承，也就是不能够派生子类。

package day11;

final class Animal{

}

class dog extends Animal{

}
public class Demo4  {
    public static void main(String[] args) {
            Dog dog=new Dog();
    }
}

 由此可见，被final关键字修饰的类为最终类，不能被其他类继承。

final关键字修饰方法：

当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。

package day11;
class Animal1{
    public final void shout(){
        System.out.println("嗷呜嗷呜！！！");
    }
}

class Dog extends Animal1{
    public void shout(){
        System.out.println("汪汪汪");
    }
}
public class Demo5 {
    public static void main(String[] args) {
        Dog dog=new Dog();
    }
}

final关键字修饰变量：

Java中被final修饰的变量称为常量，它只能被赋值一次，也就是说final修饰的变量一旦被赋值，其值不能被改变 。如果再次对该变量赋值，程序会在编译时报错。

package day11;

public class Demo6 {
    public static void main(String[] args) {
        final int num=10;//第一次可以赋值
        num=4;//再次赋值会报错
    }
}

注意：当局部变量使用final关键字进行修饰时，可以在声明变量的同时对变量进行赋值，也可以先声明变量然后再进行有且只有一次的赋值。而当成员变量被final修饰时，在声明变量的同时必须进行初始化赋值，否则程序编译会报错。 

package day11;


public class Demo7 {
final int m;
    public static void main(String[] args) {
        final int n;
        n=6;
    }
}

 这是因为使用final关键字修饰成员变量时，Java虚拟机不会对其初始化，因此使用final修饰成员变量时，需要在定义变量的同时赋予一个初始值，下面将第3行的代码修改为：

final int num=10;

保存后，IDEA的编译器就不会再提示错误。

包的概念:包就是文件夹,用来管理类文件的
包的定义格式:package  包名;(多级用.隔开)

import（导包）
导包的意义：使用不同包下的类时,使用的要写全路径,写起来太麻烦了
                    为了简化带包的操作,java就提供了导包的功能
导包的格式： import 包名.类名;

三（封装）

封装是面向对象的三大特征之一，理解并掌握封装对于学习Java面向对象的内容十分重要。

为什么需要封装（封装的好处）：属性私有化,提高数据安全性。

package day11;

class Man{
    String name;
    int age;
    public void  speak(){
        System.out.println("我叫"+name+",今年"+age+"岁了");
    }
}
public class Demo8 {
    public static void main(String[] args) {
        Man man=new Man();
        man.name="张翼德";
        man.age=-18;
        man.speak();
    }
}

在该例子中，我们将age赋值为一个负数-18，这在语法上不会有任何问题，因此程序可以正常运行，但在现实生活中明显不合理的。为了避免出现这种不合理的问题，因此在设计一个Java类时，应该对成员变量的访问作出一些限定，不允许外界随意访问。这就需要实现类的封装。

封装的含义： 类的封装，是指将对象的某些信息隐藏在对象的内部,不允许外部程序直接直接访问对象的内部信息,而是通过该类所提供的方法来实现对内部隐藏信息的操作和访问。

封装的具体实现：在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些public修饰的共有方法，其中包括用于获取属性值的getXXX( )方法和设置属性值的setXxx（）方法。

给某个属性，提供一个get方法，方便再其他地方获取此属性
     get 方法 :获取属性的方法，要获取一个结果，所以要加返回值类型
      get方法的一般格式：get方法名要满足驼峰命名法
      public 属性类型  get属性名(){ 
             return 属性;
      } 

给某个属性赋值，提供一个set方法，方便给此属性设置或者修改值
      set方法的一般格式：
      public void set属性名(属性的类型 属性名){
             this.属性名 = 属性名;
     }     

package day11;

public class Demo9 {
    private String name;
    private int age;

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name=name;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        if (age<=0){
            System.out.println("您输入的年龄不正确！！！");
        }else{
            this.age=age;
        }
    }

    public void  speak(){
        System.out.println("我叫"+name+",今年"+age+"岁了");
    }

    public static void main(String[] args) {
        Demo9 demo=new Demo9();
        demo.setName("张翼德");
        demo.setAge(-18);
        demo.speak();
    }
}

在main()方法中创建了Person类对象，并调用了setAge（）方法传入了一个负数（-18），在setAge（）方法中会对传入的age值进行检查，由于传入的-18是小于0的，所以会输出“您输入的年龄不正确！！！”。由于此时的age属性并没有被赋值，所已仍为初始值0。 

建议： 在设计类时，尽量贴合封装的原理  

封装的原理： 
            将属性私有化（加private，）目的在于在其他类中无法直接访问属性
            在本类中为这些属性添加访问的方法（行为），
            目的在于，要访问必须经过本类同意，并且由自己的行为(方法)去操作 

行为（方法）：  获取属性，  可以为属性添加 get（）方法
                         修改或者设置属性， 可以为属性添加 set（）方法 

当类中的属性私有化之后:
                                         要获取属性值，就调用对应的get方法
                                         要修改属性值，就调用对应的set方法