java基础（面向对象二）

1、面向对象特征二：继承性

 【注意】

•  通过"class A extends B"类实现类的继承。
• 子类继承父类以后，父类中声明的属性、方法，子类就可以获取到。 明确：当父类中有私有的属性或方法时，子类同样可以获取得到，只是由于封装性的设计，使得子类不可以直接调用罢了。子类除了通过继承，获取父类的结构之外，还可以定义自己的特有的成分。extends：子类是对父类功能的“扩展”，明确子类不是父类的子集。
•  java中类的继承性只支持单继承：一个类只能继承一个父类。反之，一个父类可以有多个子类。
• 子父类是相对的概念。

 1.1、方法的重写与方法的重载

重载：

• “两同一不同”：同一个类，同一个方法名，不同的参数列表。 注：方法的重载与方法的返回值无关！
• 构造器是可以重载的

重写：

• 前提：在继承的基础之上，子类在获取了父类的结构以后，可以对父类中同名的方法进行“重构” 方法的返回值，方法名，形参列表形同；权限修饰符不小于父类的同名方法；子类方法的异常类型不大于父类的。
• 两个方法要同为static或同为非static。

2、关键字super

1.super，相较于关键字this，可以修饰属性、方法、构造器

2.super修饰属性、方法：在子类的方法、构造器中，通过super.属性或者super.方法的形式，显式的调用父类的指定属性或方法。尤其是，当子类与父类有同名的属性、或方法时，调用父类中的结构的话，一定要用“super.”

3.通过“super(形参列表)”，显式的在子类的构造器中，调用父类指定的构造器！
>任何一个类(除Object类)的构造器的首行，要么显式的调用本类中重载的其它的构造器“this(形参列表)”或显式的调用父类中指定的构造器“super(形参列表)”,要么默认的调用父类空参的构造器"super()"
>建议在设计类时，提供一个空参的构造器！

3、面向对象特征二：多态性

1).多态性的表现：①方法的重载与重写   ②子类对象的多态性
2).使用的前提：①要有继承关系 ②要有方法的重写
3).格式：

Person p = new Man();//向上转型
// 虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法
p1.eat();
p1.walk();
// p1.entertainment();

4).编译时，认为p是Person类型的，故只能执行Person里才有的结构，即Man里特有的结构不能够调用,子类对象的多态性，并不使用于属性。

5).关于向下转型：
  ①向下转型,使用强转符：()
  ②为了保证不报ClassCastException，最好在向下转型前，进行判断： instanceof

// 若a是A类的实例，那么a也一定是A类的父类的实例。
		if (p1 instanceof Woman) {
			System.out.println("hello!");
			Woman w1 = (Woman) p1;
			w1.shopping();
		}

		if (p1 instanceof Man) {
			Man m1 = (Man) p1;
			m1.entertainment();
		}

4、object类(了解)

1）.java.lang.Object 类，是所有类的根父类！

2）.Object类仅有一个空参的构造器  public Object(){  }

3）.关于方法：
  ① equals(Object obj)

  public boolean equals(Object obj) {
        return (this == obj);
   }

// ==
// 1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，反之返回false
// 注：两端数据类型可以不同，在不同的情况下，也可以返回true。
// 2.引用数据类型：比较引用类型变量的地址值是否相等。

//equals():
>①只能处理引用类型变量②在Object类，发现equals()仍然比较的两个引用变量的地址值是否相等
>像String 包装类 File类 Date类这些重写Object类的equals()方法，比较是两个对象的
//"实体内容"是否完全相同。
>若我们自定义一个类，希望比较两个对象的属性值都相同的情况下返回true的话，就需要重写Object类的
 equals(Object obj)方法

② toString()方法
当我们输出一个对象的引用时，会调用toString()方法。
1.public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置
2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。
3.像String类、Date、File类、包装类都重写了toString()方法。
 

5、static关键字

5.1、static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

5.2、static修饰属性（类变量）:

 * 1.由类创建的所有的对象，都共用这一个属性。
 * 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）。
 * 3.类变量随着类的加载而加载的，而且独一份。
 * 4.静态的变量可以直接通过“类.类变量”的形式来调用。
 * 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
 * 6.类变量存在于静态域中。

5.3、 * static修饰方法（类方法）

 * 1.随着类的加载而加载，在内存中也是独一份
 * 2.可以直接通过“类.类方法”的方式调用
 * 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
 *  >静态的方法内是不可以有this或super关键字的！
 * 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

6、代码块

作用：用来初始化类的属性
分类：只能用static来修饰。

 * 静态代码块：
 * 1.里面可以有输出语句
 * 2.随着类的加载而加载，而且只被加载一次
 * 3.多个静态代码块之间按照顺序结构执行
 * 4.静态代码块的执行要早于非静态代码块的执行。
 * 5.静态的代码块中只能执行静态的结构(类属性，类方法)
 * 
 * 非静态代码块：
 * 1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
 * 2.里面可以有输出语句
 * 3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
 * 4.每创建一个类的对象，非静态代码块就加载一次。
 * 5.非静态代码块的执行要早于构造器
 * 
 * 关于属性赋值的操作：
①默认的初始化
②显式的初始化或代码块初始化(此处两个结构按照顺序执行) 
③构造器中；

7、final关键字

/*
 * final:最终的 ，可以用来修饰类、属性、方法
 * 
 * 1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
 * 
 * 2.final修饰方法：不能被重写。如：Object类的getClass()
 * 
 * 3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
 * 此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
 * 
 * 变量用static final修饰：全局常量。比如：Math 类的PI
 * 
 * >与finally finalize()区分开
 * 
 */

8、抽象abstract

abstract：抽象的，可以用来修饰类、方法

 1.abstract修饰类：抽象类
 * 1)不可被实例化
 * 2)抽象类有构造器 (凡是类都有构造器)
 * 3)抽象方法所在的类，一定是抽象类。
 * 4)抽象类中可以没有抽象方法。
 * >当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
 * 
 2.abstract修饰方法：抽象方法
 * 1)格式：没有方法体，包括{}.如：public abstract void eat();
 * 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
 * 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化
 * 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

9、接口interface

 接口（interface）  是与类并行的一个概念
 * 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
 * 2.接口是没有构造器的。
 * 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
 * 比如：class CC extends DD implements AA
 * 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象法，则此类仍为一个抽象类
 * 5.类可以实现多个接口。----java 中的类的继承是单继承的
 * 6.接口与接口之间也是继承的关系，而且可以实现多继承
 * >5,6描述的是java中的继承的特点。