面向对象---封装

这次是2021年01月15日的学习成果，总结于此，以便于之后的学习查漏补缺

封装

封装的好处

1. 安全
2. 隔离变化
3. 操作简单
4. 可重用

封装的原则

将该隐藏的隐藏起来，将该暴露的暴露出来

编译问题

public： 可见性是公共的，谁在任何地方都可以访问。

public class Student {

	public String name;
	public int age;
}

Student student = new Student();
		//调用并输出Student类中的姓名，年龄属性
		System.out.println(student.name = "小明");
		System.out.println(student.age = 21);

private ：可见性是私有的，只有类自己可以访问，其他对象都不能访问。

private String name;

那么外部对象怎么调用private属性呢？这就需要用到get、set方法，这两个方法的可见性为public。

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

入门小结

1、封装能够隐藏该类中–些功能的实现细节。让调用者通过事先实现好的方法访问类的功能和数据，同时也限制对类中数据的不合理访问。

2、对数据进行检查，有利于保护对象信息的完整和合理性。

3、便于对代码的修改和维护，提高代码的可维护性。

this 关键字

this表示当前对象，或是理解为正在创建的对象

this关键字与成员变量赋值

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) {
		this.age = age;
	}

this关键字与类中方法互调

public void run() {
		System.out.println("猫在跑");
		//在外部调用run（）方法时，eat（）方法也会被使用
		this.eat();
	}

	public void eat() {
		System.out.println("猫在吃东西");
	}

JavaBean

JavaBean，也称为POJO类，通常用于存储数据。

JavaBean 特点

1、成员属性的可见性为private;

2、每个成员属性创建get/set方法实现取值/赋值。方法命名规则是将成员属性的首字母改为大写，再加上get或set前缀。

private String name;
	private int age;
	
	//get方法返回类型是成员属性的类型
	public String getName() {
		return name;
	}

	//set方法返回类型是void，有函数参数
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

构造函数

一个类实例化的过程，即通过调用类对应的构造方法来完成对象的初始化

构造方法(Constructor)的作用

1、对对象的属性进行初始化或者进行初始化的工作。
2、与new一起使用创建对象

构造方法的特点

1、方法名与类名保持一致！

2、没有返回值类型，连void都没有(如果存在一个方法名与类名- -致，且含有返回类型，这在JAVA语法上是合法的，不过会报警告，此时该方法不被JAVA认做构造方法，则只将其当做普通的成员方法)

3、没有返回值,可以只写一个return

4、若一个类中没有显式的提供任何构造器时，系统会为其提供–个默认的无参构造器

5、若一个类中显式声明了任何构造器，那么系统将不再为其提供默认的无参构造器

定义构造函数

构造函数具有和类名相同的名称，而且不返回任何数据类型

默认构造函数

Java中的每个类都有构造函数。如果没有定义构造函数，那么JVM将提供–个默认构造函数，它没有参数且什么都不做。默认构造函数的格式如下:

public Cat() {

}

下面类中没有定义构造函数，那么创建对象时将使用默认构造函数。

public class Cat{

	private String name;
	private int age;
}

现在只能使用下面这种方式创建对象:
Cat cat = new Cat();

定制构造函数

下面例子中，实现了一个定制的构造函数

public class Cat{
	private String name;
	private int age;
	
	public Employee(String n,int a) {
		name = n;
		age = a;
	}
}

这种情况下，JVM不会再提供一个默认构造函数，只能使用定制的构造函数:

Cat cat = new Cat("橘喵", 3);

如果使用无参构造函数，那么编译将出错:
Cat cat = new Cat();

有定制构造函数时，还需要无参构造函数

下面例子中，实现了一个定制的构造函数。

如果还需要提供无参构造函数，则需要自己定义。

例如:

public class Cat {
	private String name;
	private int salary;

	public Cat() {
		// 默认构造函数，即无参构造函数
	}

	public Cat(String n, int s) {
		name = n;
		salary = s;
	}
}

现在可以使用下面两种方式创建对象:

Cat cat = new Cat();

Cat cat = new Cat("橘喵", 3);

建议:永远手动给出无参构造函数。

构造函数小结

1、如果我们没有给出构造方法，系统将自动提供一个无参构造方法

2、如果我们给出了构造方法，系统将不再提供默认的无参构造方法。注意:这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

3、如果构造方法加上了返回类型(包括void)，则此时该方法不被认为是构造方法，而会被认为是一个普通的构造方法，尽管编译器会报警告，但语法上这样写是允许的，但是通常不这样写

this关键字与构造方法

在Java中，可以使用this 方法调用本对象的其他构造函数，这是一种特殊格式。
但是请注意: this方法调用其他构造函数必须在该构造函数中的 第一个有效语句，在它的前面不能有任何有效语句，否则编译报错。

public class Cat {

	private String name;
	private int age;

	public Cat(String n, int a) {
		name = n;
		age = a;
	}

	public Cat(String n) {
		// 调用本类的构造函数Cat(String n,int a)
		this(n, 3);
	}

	public Cat() {
		// 调用本类的构造函数Cat(String n)
		this("Unknown");
	}
}

执行:
Cat cat = new Cat();

构造函数的执行顺序是：
Cat() -->Cat(String n) --> Cat(String n,int a)

因此最终的状态是:

name 值为 Unknown； age 值为 0

构造函数的重载

在一个类中可以定义多个构造函数，这称为构造函数重载。在运行时，JVM根据调用参数决定执行哪一个构造函数

public class Cat {

	private String name;
	private int age;
	
	public Cat() {
		name=null;
	}
	
	public Cat(String name, int age) {
		name = "橘喵";
		age = 3;
	}
}

执行：
Cat cat = new Cat();
由于没有参数，因此调用Cat();

Cat cat = new Cat(“橘喵” , 3);
由于参数为String ， int ，因此调用Cat(String n,int a);

构造函数与普通的函数的区别

1、普通函数用于定义对象应该具备的功能。构造函数用于定义对象的初始化内容。

2、构造函数是在对象建立时由JVM调用。普通函数是对象建立后，调用该函数时才会执行。

3、普通函数可以多次调用，构造函数就在创建对象时调用。

4、构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。

5、构造函数没有返回值类型。

static 关键字

static主要用于修饰类的属性和方法，实现类的静态属性和静态方法的共享。

静态声明

1、静态属性

在普通属性的声明中，加上static关键字，就是属性声明为静态属性。如：

public class StaticDemo {
	public static int number = 5;
}

2、静态方法

在普通方法的声明中，加上static关键字，就是方法声明为静态方法。如：

public class StaticDemo {
	public static int add(int x,int y) {
		return x+y;
	}
}

3、访问静态属性和静态方法

public class StaticDemo {
	public static int number = 5;
	public static int add(int x,int y) {
		return x+y;
	}
}

访问静态属性和静态方法时，不需要使用对象实例进行引用，只需要类名引用即可。

public class UseStaticDemo {
	public static void main(String[] args) {
		System.out.println(StaticDemo.number);
		System.out.println(StaticDemo.add(5, 6));
	}
}

4、静态代码块

静态代码块随着类的初始化而初始化，只执行一次

public class StaticDemo {
	//静态代码块，在加载类的字节码后立即执行，不需要创建对象实例
	static{
		System.out.println("static block 1");
	}
	
	static{
		System.out.println("static block 2");
	}
	//通常使用static和final配对定义常量
	public static final double PI = 3.1415926;
	
	private int i;

	public StaticDemo() {
		System.out.println("构造方法调用");
	}
	public static void main(String[] args) {
		System.out.println("StaticDemo.PI:" +StaticDemo.PI);
	}
}

静态和实例

静态属性和静态方法是属于类范围的，称为类属性或类方法。

实例属性或实例方法是属于对象范围的，称为实例属性或实例方法。

1、存放位置不同

静态属性和静态方法随着类的加载保存在方法区，而实例变量随着对象的建立而存在于堆内存中。

2、生命周期不同

实例变量和对象实例的生命周期是相同的。实例变量的内存空间就是在对象的内存空间中，是在JVM的堆中分配的。

静态变量和类的生命周期是相同的。通常将类加载到方法区后，直到JVM停止前，它都是一直存在的。，

由于静态变量类似于全局变量，它本身是违反面向对象的设计原则的。因此，除了工具方法，其它业务方法都不要使用静态方法。

3、访问方式不同

静态属性的生存期不依赖于对象，相当于C语言中全局变量的作用，可以在各个实例之间共享，其他的类不用实例化即可调用它们。

使用实例变量和实例方法之前，一定要创建相应的实例对象。

使用静态变量和静态方法之前，不需要创建相应的实例对象。

4、常见的错误情形

静态属性和静态方法可以使用类名和对象引用，在静态方法中只能访问静态变量和静态方法，不能访问非静态成员属性和方法，不可以使用this、super 关键字。

实例属性和实例方法的使用之前必须先创建实例对象，然后使用实例对象引用。在实例方法中可以访问静态属性和静态方法、实例属性和实例方法，可以使用this、super关键字。

注意事项

1、在static 方法内部只能访问static 属性和static 方法，不能访问类的实例变量和成员方法;即非static属性和非static方法

2、static 修饰的方法不能被重写，或者说不会被覆盖。因为静态方法是类方法，是属于类的，它和对象无关

3、static 方法内部不能有this和super

4、建议使用类名.静态成员访问静态变量和方法