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

本文主要是介绍面向对象（四）：[状态修饰词(static关键字、final关键字)，封装]，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一（状态修饰词static）

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修饰的的类，变量和方法有以下特性：

final修饰的类不能被继承（也就是不能有子类）。
final修饰的方法不能被子类重写。
final修饰的变量：成员变量（定义的同时必须初始化）和局部变量（可以先定义再初始化），只能被赋值一次。
static和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();}
}