面向对象

面向对象分为：封装、继承、多态

封装

封装的目的就是为了提高访问的安全性
从这里，先需要了解访问修饰符，有四种public，default，protected，private

  1. public（访问权限最高）：类内随便访问，随便调用。类外部可以调用，子类可以调用，非子类也可。就是说，只要是在同一个项目里就可以访问
  2. default（默认）：同一个包中的其他类都可以访问
  3. protected：类内随便访问，随便调用。还有只能子类访问，非子类不可以
  4. private（私有）：只有本类中科院访问，即使子类也不可以。也是从一个角度太体现封装

还有一个static关键词，静态变量全局共享，静态方法无法调用实例变量和实例方法。

然后呢就是关于类的介绍：

一个类的组成：

  1. 构造函数：也叫构造方法，不能通过手动创建对象调用
    1. 构造方法与类名一致
    2. 没有返回值类型的声明
    3. 访问修饰符可选
    4. 不能够手动调用
    5. 与创建对象时相关的，创建对象时即会引用，同时依赖构建函数的形参。因为构造方法是可以在同一个类中重载的（多态的第一种体现），可以有很多个构造方法，但是拥有不同的形参，有不同的结果
    6. 如果author没有提供任何构造函数，Java编译器会在编译时自动提供无参构造函数
  2. 实例方法
  3. 静态方法
  4. 静态块：在main函数定义的类中最先被加载，且只加载一次。
    使用规则：只能使用静态变量，不能使用实例变量，不能使用this关键字
  5. 匿名构造块：对象创建之前都会执行这个代码块
    直接上代码理解一下
public class Emp3 {
	static{
		System.out.println("静态块");
	}
	//匿名构造块{
		System.out.println("匿名构造块");
	}
	Emp3(){
		System.out.println("无参构造函数");
	}
	Emp3(int a){
		System.out.println("带参构造函数" +a);
	}
	public static void main(String[] args) {	
		Emp3  e1  = new Emp3(20);
		Emp3  e2  = new Emp3();
	结果：
	//静态块---在有main函数的类中最先执行
	//匿名构造块---在e1对象创建时运行
	//带参构造函数20---e1对象创建是产生的带参构造函数
	//匿名构造块---在e2对象创建时运行
	//无参构造函数---e2对象创建是产生的无参构造函数
	}

继承

说白了就是先定义一个父类 public class Dad
然后来个子类public class Son extends Dad，这就是最朴素的继承
通过继承，子类可以使用父类的方法，通过创建子类的对象，然后就可以.出父类的方法或者值了（当然了，不能是private修饰的蛤）
同时，关于父类的构造函数呢也有别的说法：

  1. 如果父类中有无参构造函数
    那万事大吉，咱啥事也没有，担任你也可以自己找点事
public class Son   extends Base {
	public Son()
	{
		//父类中提供了默认无参构造函数，子类可以写super()，也可以不写。
		//super();
	}
}
  1. 如果父类有带参构造函数，那就有事了
    父类中提供了有参数的构造函数，子类必须使用super(参数)，且必须在第一行

但是正常来说，一个爹也是可以拥有两个儿子的是吧，所以就会引出下一个定义--动态绑定：是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法
从这里就会引出多态的第二个概念：重写
重写是发生在父类与子类之间

  1. 子类和父类具有相同的方法名，相同的参数列表(个数和类型相同)，相同的返回值类型， 称为方法重写。
  2. 子类方法重写的访问修饰大于等于父类访问修饰 public->protected->default-private
  3. 被final修饰的父类方法不可以被重写，只能在本类中被重载哦。final，断子绝孙呢~ 被final修饰的变量也会变成常量，不可被修改

至此，多态就结束了，就仿佛，封装与继承，都体现了多态，三者是不可分割的
总结一下，多态：重载&重写

Q.E.D.