封装和static

理解封装的作用

为什么要使用封装

Penguin p=new Penguin();
p.health = -1000; //错的   健康值不可能为负

属性随意访问，不合理的赋值。
所以才要使用封装

什么是封装
面向对象的三特性：封装、继承、多态
面向对象特征：封装

封装的概念
将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问
把尽可能多的东西藏起来，对外提供便捷的接口

封装目的是为了保护属性不被随意修改

如何实现封装:

1. 私有化属性
   （设为private关键字，防止错误的修改）
2. 创建公共的getter/setter方法作为出口和入口
   （用于属性的读写 ）
3. 在getter/setter方法中加入属性控制语句
   （对属性值的合法性进行判断 ）
4. 赋值的时候调用setter方法，获取值的时候用getter方法

举例：

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

p.setName("小猪");
String a = p.getName();
System.out.println(a);

如果有有参构造，则赋值时建议调用setter方法，保障逻辑完整性
有参构造是相当于另一个接口，那就是新的，此时属性都已经私有化，
之前的getter和setter方法是针对无参构造方法的，对有参构造不管用。

举例：

public Penguin(String name, int health) {
		this.name = name;
		setHealth(health);
	}

快捷键：
alt + shift + s
Source - Generate Getters and Setters

封装的好处:
便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

Java中的包组织类
为什么需要包
比如Windows树形文件系统

• 文档分门别类，易于查找和管理
• 使用目录解决文件同名冲突问题

包对应Java源文件的目录结构

包的作用 :（package）

1. 允许类组成较小的单元（类似文件夹），
   易于找到和使用相应的文件
2. 防止命名冲突，区分名字相同的类
3. 有助于实施访问权限控制

如何创建包
作为Java源代码第一条语句
用package声明包，以分号结尾
package xx.xxx;//声明包

包命名规范

• 包名由小写字母组成，不能以圆点开头或结尾
  举例：package mypackage;
• 包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
  举例：package net.javagroup.mypackage;
• 包名后续部分依不同机构内部的规范不同而不同
  举例：package net.javagroup.research.powerproject;

JDK提供基本包
java.lang：虚拟机自动引入
java.util：提供一些实用类
java.io:输入、输出

java.lang等基本包下的所有类不需要import导入

使用MyEclipse创建包的两种方法
分别创建包和类
创建类的过程中创建类所在的包（如下）

如何导入包：
为了使用不在同一包中的类，
需要在Java程序中使用import关键字导入这个类。

import 包名. 类名；
举例：
import java.util.*; //导入java.util包中所有类
import cn.test.class.School; //导入指定包中指定类

1. 系统包：java.util
2. 自定义包：cn.test.class
   *： 指包中的所有类，表示通配符
   School ：指包中的School类

使用包的注意点：

1. 一个类同时引用了两个来自不同包的同名类
   必须通过完整类名来区分
2. 每个包都是独立的，顶层包不会包含子包的类
3. package和import的顺序是固定的
   ==>package必须位于第一行（忽略注释行）
   只允许有一个package语句
   其次是import
   接着是类的声明
4. 不能删除包，不然会报错的(package) 。
5. 默认包不要创建，不要放东西。

因为其他类想调用默认包里的，不能调用，比较麻烦，会找不到默认包下的对象。

导包快捷键：
ctrl + shift + o

掌握访问修饰符，理解访问权限
访问修饰符：

权限修饰（访问修饰符）：
public:公共的，工程内所有的类都能访问（绝大部分的方法）
protected:包级私有 + 子类，在默认修饰符的基础上加子类可访问
默认(default)：包级私有，本包内所有类可以访问（临时变量）

default 和 friendly都可以，但默认修饰符前面不能加东西！

private：私有的，只有本类可以访问(基本是所有的属性）

static关键字（修饰符）
static可以用来修饰

1. 成员变量（属性）
   静态变量，可以直接通过类名访问
2. 成员方法
   静态方法，可以直接通过类名访问
3. 代码块
   静态代码块，当Java虚拟机加载类时，就会执行该代码块

1、static在修饰属性时:

• 共用一个存储空间，不同对象调用时可以保存修改
  （会有公用的空间，保障该类所有实例访问的是同一个位置）
• 可以不用对象调用（不用创建对象），而用类调用
• 静态属性可以在普通方法中调用，也可以在静态方法中调用
• 普通属性不能在静态方法中直接调用，需要用对象.属性的方式调用

类的成员变量包括
类变量（静态变量）

public class Stu {
static int a =1; //类属性
}

==>类的不同对象共用一个存储空间
（就是在main方法中使用时，不管创建了多少的对象，
里面只要有关a你都能使用）

概念：

• 类变量就是被static修饰的变量
• 在内存中只有一个拷贝
• 类内部，可在任何方法内直接访问静态变量
• 其他类中，可以直接通过类名访问
  ==>当你在外部去调用该类，可以直接用 类名.静态属性 来调用
  好处是：不用建对象 Stu.a ++;
• 用static修饰的属性，那么该属性在方法区，都是这个值 一旦改了，那就都是这个值，一起改变。

执行顺序：从上往下 从左往右（static根据这个来改变）

实例变量

int b =1;//对象属性   每创建一个对象就是一个新的b

==>每创建一个对象，那么b就只对该对象有作用

概念：

• 没有被static修饰的变量
• 每创建一个实例，就会为实例变量分配一次内存，
  实例变量可以在内存中有多个拷贝，互不影响

static变量的作用：

public class StaticTest {
         static int num;
         public static void main(String[] args) {
                 num++;
                 StaticTest st1=new StaticTest();
                 st1.num++;
                 StaticTest st2=new StaticTest();
                 st2.num++;
                 StaticTest.num++;
                 System.out.println(num); 
        }
}

结果为：4

（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，
可把这个属性定义为静态常量类型，从而节省内存空间

2、static修饰方法时（静态方法）:

public class Stu {
public static void aaa() {//类方法
	}
}

• 静态方法可以直接用类名.静态方法()调用
  （在Stu中直接调用静态方法aaa();，同时在外部main调用可以通过
  类来调用Stu.aaa();原因都是静态方法）
• 静态方法通常用于做工具方法()，不需要创建对象即可使用
  （Array.toString(）Math.random() 等等都是属于静态方法）
• 静态方法可以调用静态方法，不能直接调用普通方法，需要用对象调用（创建对象）
• 普通方法可以直接调用静态方法和普通方法

注意点：

1. 静态方法中不能使用this和super（它们是针对对象）
2. 不能直接访问所属类的实例变量和实例方法
3. 可直接访问类的静态变量和静态方法

main()就是最常用的静态方法

注意点：
在实例方法里不可以定义和使用static变量

实例（对象）方法：通过实例访问

• 可直接访问所属类的静态变量、静态方法、实例变量和实例方法

3、static代码块:

//静态代码块
public class Test1 {
	static {
		System.out.println("初始化之前就会执行，且只有一次");
	}
	public TestBlock() {
		System.out.println("自定义无参构造");
	}//无参构造方法只要创建一个对象就会走一次
	public static void main(String[] args) {
		Test1 t = new Test1();
		Test1 t2 = new Test1k();
		Test1 t3 = new Test1();
	}
}

结果:
初始化之前就会执行，且只有一次
自定义无参构造
自定义无参构造
自定义无参构造

• 静态代码块会在第一次访问该类型时，执行并只执行一次.
• 会在对象创建前就执行静态代码块(JVM加载类时，加载静态代码块)
• 如果有多个静态块，按顺序加载
• 静态代码块往往用于配置文件的导入，单例模式的关键点

举例：

public class StaticTest {
         static int num=100;
         static{
                num+=100;
               System.out.println(num);
         }
         static{
                num+=100;
               System.out.println(num); 
        }
}

StaticTest st1=new StaticTest();
StaticTest st2=new StaticTest();
System.out.println(StaticTest.num);

结果:
200
300
300

假设上面即使不写创建两个对象
但只要看到这个类型 比如类. 变量名
那么在执行这句话之前 就会调用 static 代码块

题外话：

Java中静态代码块、构造代码块、普通代码块
静态代码块： (在类中)

 public class Test1 {
    static{
        System.out.println("静态代码块");
    }
}

注意点：

1. 静态代码块在类被加载的时候就运行了，而且只运行一次。
2. 如果一个类中有多个静态代码块，会按照顺序依次执行。
3. 静态代码块不能存在任何方法体中
4. 静态代码块不能访问普通变量

作用： 为了让代码需要在项目启动的时候就执行。

构造代码块: (在方法中)

public class Test2 {
    {
        System.out.println("构造代码块");
    }
}

注意点：

1. 构造代码块在创建对象时被调用，每次创建对象都会调用一次，
   但是优先于构造函数执行。
2. 如果不实例化对象，构造代码块是不会执行的。

作用： 对对象进行初始化

普通代码块: (在类中)

public void ATest3(){
    {
        System.out.println("普通代码块");
    }
}

注意点： 普通代码块是在方法体中定义的(类中方法的方法体)。

执行顺序:
静态代码块>构造代码块>（构造函数）>普通代码块

注意点： 静态是单独的，而构造代码块和构造函数是捆绑执行的

相关变量的销毁：
静态成员变量在类加载的时候就进行了创建，在整个程序时按序销毁
实例变量在类实例化对象时候创建，在对象销毁的时候销毁
局部变量在局部范围使用时创建，跳出局部范围销毁

问题解决：
当遇到以下问题：
The left-hand side of an assignment must be a variable
其中之一的问题：
Java可把一个对象赋值给一个引用（变量），但是不能把对象赋值给对象 。
比如：h.getHeal() = h.getHeal() - damage;
相当于 5=5-1， 你get，只是拿到个数字，而不是这个变量，
而set 方法是专门给这个变量赋值的。
正确写法：setHeal(getHeal() - damage);

方法的定义没有先后顺序，只有实际调用的时候才看顺序

main方法不同，就路径也不同，是独立的，互不相干。

没有造对象 那么无参构造也不会调用

----2021.08.06