第七天知识(封装，继承)

1. 封装
   我们将属性私有化（private）的同时，提供了get和set方法将属性值进行获取和修改
   体现:单例模式，不对外暴露的私有的方法
2. 修饰符：
   1.java规定的四种:public(公开) 、protected(保护)、缺省、private。(从大到小)
   2.上述四种可以修饰类的内部结构:属性，方法，构造器、内部类
   3.Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的
   大小。
   4.JavaBean是一种Java语言写成的可重用组件。所谓JavaBean，是指符合如下标准的Java类：

   类是公共的
   有一个无参的公共的构造器
   有属性，且有对应的get、set方法

3. 类的构造器
   1.有参构造器和无参构造器
   2.作用:创建对象
   初始化对象信息
4. 说明：
   1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
   2.定义构造器的格式：权限修饰符 类名(形参列表){}
   3.一个类中定义的多个构造器，彼此构成重载
   4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
   5.一个类中，至少会有一个构造器。
   总结：属性赋值的先后顺序
   ① 默认初始化
   ② 显式初始化
   ③ 构造器中初始化
   ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
   以上操作的先后顺序：① - ② - ③ - ④
5. package的作用:
   1.为了更好的实现项目中类的管理，提供了包的概念
   2.使用package声明类或接口所属的包，声明在源文件的首行
   3.包，使用标识符，遵循规范:(com.xxx.xxx)
   4.补充：同一个包下，不能命名同名的接口、类。
   不同的包下，可以命名同名的接口、类。
6. import：导入
   1.在java.lang包下不需要声明，
   2.在本包下定义额类或接口也不需要import声明
   3.使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要
   显式导入
7. this使用:
   this可以修饰、调用:属性，方法，构造器
   this理解为当前对象或者当前创建的对
8. 继承
   1.好处:减少代码的冗余，提高了代码的复用性
   便于功能的扩展
   为了多态使用提供前提
   2.格式：class A extends B{}
   A.子类，派生类，subclass
   B.父类，超类，基类，superclass
   3.体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父
   类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为
   封装性的影响，使得子类不能直接调用父类的结构而已。
   4.子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
   子类和父类的关系，不同于子集和集合的关系。
   extends：延展、扩展
9. Java中关于继承性的规定：
   1.一个类可以被多个子类继承。
   2.Java中类的单继承性：一个类只能有一个父类
   3.子父类是相对的概念。
   4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
   5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
10. 如果没有继承那么它的父类就是Object
11. 方法的重写(override / overwrite)：
    1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
    2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际
    执行的是子类重写父类的方法。
    3.重写的规定：
    方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
12. super关键字:
    在子类中可以使用super.属性或者super,方法，显示调用
    super调用构造器:super()为无参构造器、super(属性,属性,属性)为有参构造器
13. 多态

class A{
	public A(){
		System.out.println("这是父类A构造方法");
	}
	public void eat(){
		System.out.println("这是父类的eat方法");
	}
}
class  B extends A{
	public B(){
		super();
		System.out.println("这是子类B的构造方法");
	}
	public void eat(){
		System.out.println("这是子类B的eat方法");
	}
}
class C extends A{
	public C(){
		super();
		System.out.println("这是子类C的构造方法");
	}
	public void eat(){
		System.out.println("这是子类C的eat方法");
	}
}
class Demo{
	public static void main(String[] args[]){
		methon(new B());
		methon(new C());
	}
	public static void methon(A a){
		a.eat();
	}
}

:如有错误联系我，改之