标签：
四、类和对象2
主要内容：Java类的继承、方法的重写、覆盖、访问控制、super 关键字、多态性及其应用
1.继承
要求：Java只支持单继承，不允许多重继承
一个子类只能有一个父类
一个父类可以派生出多个子类
子类继承了父类，就继承了父类的方法和属性。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
因而，子类通常比父类的功能更多。
在Java 中，继承的关键字用的是“extends”，即子类是对父类的“扩展”。
注意：子类不能继承父类中私有的(private)成员变量和方法。
2.访问控制
3.方法重写
在子类中可以根据需要对从父类中继承来的方法进行改造重写方法，在程序执行时，子类的方法将覆盖父类的方法。
方法重写必须和被重写的方法具有相同的方法名、参数列表和返回值类型。
重写方法不能使用比被重写方法更严格的访问权限。
4.super关键字
在Java类中使用super关键字来引用父类的成分
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造方法中调用父类的构造方法
示例：public class Person {
private String name;
private int age;
public String getInfo() {
return "Name: " + name + "\nage: " + age;
}
}
public class Student extends Person {
private String school = "New Oriental";
public String getSchool(){
return school;
}
public String getInfo() {
调用父类的方法
return super.getInfo() +"\nschool: " +school;
}
}
补充：super与父类构造方法的调用
子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法
在子类的构造方法中可使用super(参数列表)形式的语句调用父类的构造方法
如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错
5.多态性
多态：子类的对象可以替代父类的对象使用
一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
Object o = new Person();Object类型的变量o，指向Person类型的对象
o = new Student(); Object类型的变量o，指向Student类型的对象
父类类型的变量可以指向子类的对象
Person p = new Student();
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。
Student s = new Student();
s.school = “hp”; 合法
Person p = new Student();
p.school = “hp”; 非法
正常的方法调用
Person p = new Person();
p.getInfo();
Student s = new Student();
s.getInfo();
动态绑定
Person p = new Student();
p.getInfo(); 调用Student类的getInfo()方法
在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际类型调用其相应的方法。
方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法
public class Test{
public void method(Person p) {
……
p.getInfo();
}
public static void main(Stirng args[]){
Test t = new Test();
Student s = new Student();
t.method(s); 子类的对象s传送给父类类型的参数p
}
}
6.instanceof操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person p) {
if (p instanceof Person)
处理Person类及其子类对象
if (p instanceof Student)
处理Student类及其子类对象
if (p instanceof Graduate)
处理Graduate类及其子类对象
}
7.对象类型转换
基本数据类型的转换：
小的数据类型可以自动转换成大的数据类型
如long g=20; double d=12.0f
可以把大的数据类型强制转换成小的数据类型
如 floate f=(float)12.0 int a=(int)1200L
对Java对象的强制类型转换
从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过强制类型转换实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型
public class Test{
public void method(Person p) {
System.out.pritnln(p.getschool()); 不推荐
if(p instanceof Student){ 推荐
Student me = (Student)p;
System.out.pritnln(me.getschool());
}
}
public static void main(Stirng args[]){
Test t = new Test();
Student s = new Student();
t.method(s);
}}
五、类和对象3
主要内容：static 关键字、final 关键字、抽象类、接口、内部类
（一）static关键字:
静态的，可以用来修饰属性、方法、代码块（或初始化块）、内部类
static修饰属性（类变量）:
1.由类创建的所有的对象，都共用这一个属性
2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
3.类变量随着类的加载而加载的，而且独一份
4.静态的变量可以直接通过“类.类变量”的形式来调用
5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
6.类变量存在于静态域中。
static修饰方法（类方法）:
1.随着类的加载而加载，在内存中也是独一份
2.可以直接通过“类.类方法”的方式调用
3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
>静态的方法内是不可以有this或super关键字的！
注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构
main方法
public static void main(String[] args){
方法体
}
1.main()是一个方法，是主方法，为程序的入口
2.权限修饰符：public protected 缺省 private ---面向对象的封装性
3.对于方法来讲：static final abstract
4.方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。 形参 & 实参---方法的参数传递机制：值传递
7.方法体：方法定义的是一种功能，具体的实现由方法体操作。
代码块：
是类的第4个成员
作用：用来初始化类的属性
分类：只能用static来修饰。
静态代码块：
1.里面可以有输出语句
2.随着类的加载而加载，而且只被加载一次
3.多个静态代码块之间按照顺序结构执行
4.静态代码块的执行要早于非静态代码块的执行。
5.静态的代码块中只能执行静态的结构(类属性，类方法)
非静态代码块：
1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
2.里面可以有输出语句
3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
4.每创建一个类的对象，非静态代码块就加载一次。
5.非静态代码块的执行要早于构造器
关于属性赋值的操作：
①默认的初始化
②显式的初始化或代码块初始化(此处两个结构按照顺序执行)
③构造器中；
—————————以上是对象的属性初始化的过程—————————————
④通过方法对对象的相应属性进行修改
（二）final关键字
final:最终的 ，可以用来修饰类、属性、方法
1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
2.final修饰方法：不能被重写。如：Object类的getClass()
3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。
此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
变量用static final修饰：全局常量。比如：Math 类的PI
>与finally finalize()区分开
/
class D{
final int I = 12;
final double PI;
final String NAME;
public void m1(){
System.out.println(I);
// I = 10;
}
{
PI = 3.14;
}
public D(){
NAME = "DD";
}
public D(String name){
this();
//NAME = name;
}
}
（三）抽象类
重点！
abstract：抽象的，可以用来修饰类、方法
1.abstract修饰类：抽象类
1)不可被实例化
2)抽象类有构造器 (凡是类都有构造器)
3)抽象方法所在的类，一定是抽象类。
4)抽象类中可以没有抽象方法。
>当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
2.abstract修饰方法：抽象方法
1)格式：没有方法体，包括{}.如：public abstract void eat();
2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化
4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！
补充：抽象类和接口的区别
1.抽象类里可以有构造方法，而接口内不能有构造方法。
2.抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
3.抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的，不能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public ，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5.抽象类中可以包含静态方法，接口内不能包含静态方法。
6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static类型，并且默认为public static类型。
7.一个类可以实现多个接口，但只能继承一个抽象类。
8.接口更多的是在系统框架设计方法发挥作用，主要定义模块之间的通信，而抽象类在代码实现方面发挥作用，可以实现代码的重用。
（四）接口
接口（interface） 是与类并行的一个概念
1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
2.接口是没有构造器的。
3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
比如：class CC extends DD implements AA
4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
5.类可以实现多个接口。----java 中的类的继承是单继承的
6.接口与接口之间也是继承的关系，而且可以实现多继承
>5,6描述的是java中的继承的特点。
7.接口与具体的实现类之间也存在多态性
（五）内部类
类的第5个成员：内部类
1.相当于说，我们可以在类的内部再定义类。
外面的类：外部类。 里面定义的类：内部类
2.内部类的分类：成员内部类（声明在类内部且方法外的） vs 局部内部类(声明在类的方法里)
3.成员内部类：
3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法
3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器
4.局部内部类：
5.关于内部类，掌握三点：
①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）
②如何区分调用外部类、内部类的变量(尤其是变量重名时)
③局部内部类的使用
总结及补充：
面向对象的三大特性：
封装性：
① 通过私有化类的成员变量，通过公共的getter和setter方法来调用和修改
② 还可以对类的其他结构进行“封装”
③ 权限修饰符：public protected 缺省 private
继承性：
通过让一个类A继承另一个类B，就可以获取类B中的结构（主要的：属性、方法、构造器）。子类：类A 父类：类B
>java中的类的继承性：单继承的。
多态性：
①体现：方法的重载与重写 ； 子类对象的多态性 Person p = new Student();
②子类对象多态性的使用：虚拟方法调用。
③向上转型 向下转型 Student s = (Student)p; //建议在向下转型之前： if ( p instanceof Student)避免出现ClassCastException的异常
其它关键字：
1. this:修饰属性、方法、构造器 。表示：当前对象或当前正在创建的对象
2. super：修饰属性、方法、构造器。显式的调用父类的相应的结构，尤其是子父类有重名的方法、属性
3. static : 修饰属性、方法、代码块、内部类。随着类的加载而加载！
4. final：修饰类、属性、方法。表示“最终的”
5. abstract : 修饰类、方法
6. interface：表示是一个接口，（接口是与类并列的一个结构）。类与接口之间同时“implements”发生关系。
7. package import 。。。
>abstract不能修饰属性、构造器、不能与final static private共用。
标签：
原文地址：http://www.cnblogs.com/zjfjava/p/5820196.html
