封装的概念和特点
封装
- 隐藏对象的信息
- 留出访问接口
其实生活中的许多操作都是封装好的，比如ATM机，我只要按照接口操作即可，不必关心内部的具体实现。
封装的代码实现
Java中的如何实现封装呢？主要通过以下三个步骤。
getter和setter可以通过IDE快速进行生成。
建议在使用构造函数给属性赋值的时候，也使用setter，这样就可以有对赋值的判断语句。
package com.imooc.animal;
/**
* 宠物猫类
*
* @author rowrycho
*
*/
public class Cat {
// 属性：昵称、年龄、体重、品种
private String name;
private int month;
private double weight;
private String species;
// 构造方法
public Cat() {
System.out.println("这是无参构造方法");
}
public Cat(String name) {
this(); // 调用无参构造方法
System.out.println("这是有参构造方法");
}
// 构造方法中也使用setter来进行赋值操作
public Cat(String name, int month, double weight, String species) {
this("你好");
this.setName(name);
this.setMonth(month);
this.setWeight(weight);
this.setSpecies(species);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
if(month<=0)
System.out.println("输入信息错误，宠物猫年龄必须大于0");
this.month = month;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
}
使用包进行类管理
Java中包的作用就是类似操作系统中文件夹的作用，包就是用来管理类文件的。
包的作用：
- 管理Java文件
- 解决同名文件冲突
注意：package语句必须放在程序的第一行。
因为单一职责原则，所以建议每个包内存储信息功能单一。
如何在A包中引入B包中的类？
import com.imooc.animal.*; // * 表示导入animal中全部类
import com.imooc.animal.Cat; // 只导入annimal中的Cat类
建议采用import 包名。类名;的方式加载，提高效率。
同时注意，import com.imooc.*并不能加载全部的类！因为import 包名.*只能访问指定包名下的类，无法访问子包下的类。
如果导入的两个不同包出现了同名类，那么应该如何解决呢？
二者都使用全部路径，或者其中一方使用全路径即可。
public class Test {
public static void main(String[] args) {
// 使用全部路径导入，避免c
com.imooc.animal.Cat one = new com.imooc.animal.Cat();
com.imooc.mechanics.Cat two = new com.imooc.mechanics.Cat();
}
}
static关键字
public class Cat{
// static:静态 静态成员、类成员
public static int price;
public static void main(String[] args){
Cat one = new Cat();
one.price=150; // price=150
Cat two = new Cat();
two.price=300; // price=300
System.out.println(one.price); // price为300！
}
}
对象成员就是创建对象的时候才有，对象销毁时就会被删除。
但是static修饰的类成员，从类创建开始就存在，直到类被销毁才消失，而且每一个对象都是使用同一个类变量，也就是说不同对象操作是同一个类成员！
- 类对象共享
- 类加载时产生，销毁时释放，生命周期长
静态成员的访问方式
推荐通过 类.成员 的方式进行调用
one.price=200; // 对象.成员
Cat.price=200; // 类.成员
one.eat();
Cat.eat();
static的使用范围
- static + 成员属性
- static + 成员方法
静态成员不能调用非静态成员，非静态成员可以调用静态成员，使用this也是不小的（从加载顺序来进行理解）
代码块
代码块
- 普通代码块： 顺序执行，先出现，先执行
- 构造代码块：创建对象时调用，优先于构造方法执行
- 静态代码块：类加载时调用，优先于构造代码块执行
package com.imooc.animal;
/**
* 宠物猫类
*
* @author rowrycho
*
*/
public class Cat {
...
static {
System.out.println("这是静态代码块1");
}
static {
System.out.println("这是静态代码块2");
}
{
System.out.println("这是构造代码块1");
}
{
System.out.println("这是构造代码块2");
}
...
public void eat() {
{
System.out.println("这是普通代码块");
}
System.out.println("小猫吃鱼");
}
}
package com.imooc.animal;
public class CatTest {
public static void main(String[] args) {
// 实例化对象
Cat one = new Cat("花花", 2, 1000, "英国短毛猫");
Cat two = new Cat();
}
}
可以看到上图执行结果，静态代码块只会加载一次，而构造代码块每次新创建一个对象的时候会有加载。
- 无论产生多少类实例，静态代码块只会执行一次
- 仅希望执行一次的代码可以放在静态代码块中
执行顺序：静态代码块>构造代码块>构造方法
小结
封装
封装
* 隐藏对象的信息
* 留出访问接口
其实生活中的许多操作都是封装好的，比如ATM机，我只要按照接口操作即可，不必关心内部的具体实现。
在Java代码中如何实现封装？
Java代码实现封装的三步骤：
* 将属性设置为private
* 创建public 的 getter 和 setter方法
* 在getter/setter方法中加入属性控制语句
private关键字
使用了private关键字修饰，那么只能在类的内部进行访问
构造方法和setter
建议在使用构造函数给属性赋值的时候，也使用setter，这样就可以有对赋值的判断语句。
// 构造方法中也使用setter来进行赋值操作
public Cat(String name, int month, double weight, String species) {
this("你好");
this.setName(name);
this.setMonth(month);
this.setWeight(weight);
this.setSpecies(species);
}
包的作用：
包的作用：
* 管理Java文件
* 解决同名文件冲突
一个包内不运行存在两个同名的类，如果两个类要同名，就要在两个不同的包中。
注意：package语句必须放在程序的第一行。
因为单一职责原则，所以建议每个包内存储信息功能单一。
包的使用
如何在A包中引入B包中的类？
import com.imooc.animal.*; // * 表示导入animal中全部类
import com.imooc.animal.Cat; // 只导入annimal中的Cat类
建议采用```import 包名。类名;```的方式加载，提高效率。
同时注意，```import com.imooc.*```并不能加载全部的类！因为```import 包名.*```只能访问指定包名下的类，无法访问子包下的类。
java.lang是默认导入的包，其中有String、Math、System
如果导入的两个不同包出现了同名类，那么应该如何解决呢？
二者都使用全部路径，或者其中一方使用全路径即可。
public class Test {
public static void main(String[] args) {
// 使用全部路径导入，避免冲突
com.imooc.animal.Cat one = new com.imooc.animal.Cat();
com.imooc.mechanics.Cat two = new com.imooc.mechanics.Cat();
}
}
static修饰符
对象成员就是创建对象的时候才有，对象销毁时就会被删除。
**但是static修饰的类成员，从类创建开始就存在，直到类被销毁才消失，而且每一个对象都是使用同一个类变量，也就是说不同对象操作是同一个类成员！**
* 类对象共享
* 类加载时产生，销毁时释放，生命周期长
静态成员的访问方式
推荐通过 类.成员 的方式进行调用
one.price=200; // 对象.成员
Cat.price=200; // 类.成员
one.eat();
Cat.eat();
static修饰符使用范围
* static + 成员属性
* static + 成员方法
静态成员不能调用非静态成员，非静态成员可以调用静态成员，使用this也是不小的（从加载顺序来进行理解）
代码块
代码块
* 普通代码块： 顺序执行，先出现，先执行（可以用于处理局部变量的同名问题）
* 构造代码块：创建对象时调用，优先于构造方法执行
* 静态代码块：类加载时调用，优先于构造代码块执行
可以看到上图执行结果，静态代码块只会加载一次，而构造代码块每次新创建一个对象的时候会有加载。
**执行顺序：静态代码块>构造代码块>构造方法**