黑马程序员_JAVA面向对象基础

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------

 面向对象的三大特征：封装  (Encapsulation)，继承  (Inheritance)，多态  (Polymorphism)
1.封装的原则
　　　封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

　　所有的类都继承自java.lang.Object，一些常用的方法：

　　　　equals():比较两个对象引用时否相同。

　　　　getClass():返回对象运行时所对应的类的表示，从而得到相应的信息

　　　　toString():返回对象字符串表示

　　　　finalize():用于在垃圾收集前清除对象

　　　　notify(), notifyall(), wait(): 用于多线程处理中的同步

　　子类（subclass）对父类（superclass，超类）的继承

　　子类不能继承父类中访问权限为private的成员变量和方法。

　　子类可以重写父类的方法，及命名与父类同名的成员变量。

　　Java不支持多重继承

 

　　创建子类

　　　　class ChildClass extends SuperClass {

　　　　　　...

　　　　}

 

　　成员的隐藏和方法的重写

　　　　子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为变为自身的状态和行为。

　　　　

2.多态性
　　子类继承父类后，同一个方法有不同的表现

　　体现在两个方面：方法重载实现的静态多态性（编译时多态），方法重写实现的动态多态性（运行时多态）

　   重写方法的调用原则：子类重写父类的方法，调用子类方法；反之，调用父类的方法

 

　　一个对象可以引用子类的实例来调用子类的方法

　　eg: B继承A，A的对象a引用B的实例，调用B的方法testCall()

import java.io.*;
class A {
    void testCall() {
        System.out.println(" A调用testCall()");
    }
}

class B extends A {
    void testCall() {
        System.out.print("B调用 testCall()");
    }
}

public class Dispatch {
    public static void main(String args[]) {
        A a = new B(); // 引用子类的实例
        a.testCall();
    }
}

运行结果:"B调用 testCall()

类的实现
　　类声明
　　　　[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {}
　　　　　　修饰符public, abstract, final说明类的属性
　　　　　　className为类的属性
　　　　　　superclassName为父类的名字
　　　　　　interfaceNameList为类所实现的接口列表

　　类体
　　　　class className
　　　　{
　　　　　　[public | protected | private] [static] [final] [transient] [volatile] type variableName; // 成员变量
　　　　　　[public | protected | private] [static] [final | abstract] [native] [synchronized] returnType methodName(
　　　　　　　　[paramList]) [throws exceptionList] {statements}; //成员方法
　　　　}

　　成员变量
　　　　[public | protected | private] [static] [final] [transient] [volatile] type variableName; // 成员变量
　　　　　　static: 静态变量（类变量）
　　　　　　final: 常量
　　　　　　transient：暂时性变量，用于对象存档
　　　　　　volatile：共享变量，用于并发线程的共享

　　成员方法
　　　　[public | protected | private] [static] [final | abstract] [native] [synchronized] returnType methodName(
　　　　[paramList]) [throws exceptionList] {statements}; //成员方法
　　　　　　static: 类方法，可通过类名直接调用
　　　　　　abstract: 抽象方法，没有方法体
　　　　　　final：方法不能被重写
　　　　　　native：集成其他语言的代码
　　　　　　synchronized：控制多个并发线程的访问

　　

　　Java类中的限定词：

　　　　private：类中限定为private的成员，只能被这个类本身访问。如果构造方法为private，则其他类不能实例化该类。

　　　　default：不加任何访问权限，可以被这个类本身和同一个包中的类访问。

　　　　protected：类中限定为protected的成员，可以被这个类本身、它的子类和同一个包中的其他类访问。

　　　　public：类中被限定为public的成员，可以被所有类访问。

　　　　

　　final关键字可以修饰类、类的成员变量和成员方法，但作用不同

　　　　修饰成员变量：称为常量，须给出初始值

　　　　修饰成员方法：该方法不能被子类重写

　　　　修饰类：类不能被继承

　　

 

　　　　super: 访问父类的成员　

　　　　　　访问父类被隐藏的成员变量，如super.variable;

　　　　　　调用父类中被重写的方法，如super.Method([paramlist]);

　　　　　　调用父类的构造函数，如super([paramlist]);

     简单数据类型作为参数传递时，为值传递；复合数据类型作为参数传递时，为地址传递

  

    方法重载

　　　　指多个方法享有相同的名字。这些方法的参数必须不同（参数个数或者参数类型不同）。且参数类型区分度要足够：如不能使同一简单类型的数据：int与long

构造方法

　　　　一个特殊的方法。每个类都有构造方法，用来初始化该类的一个对象。

　　　　构造方法具有和类名相同的名称，不返回任何数据类型。

　　　　重载经常用于构造方法。

　　　　构造方法只能由new运算符调用

 

　　抽象类和抽象方法：

　　　　用abstract关键字修饰类:抽象类

　　　　用abstract关键字修饰方法：抽象方法

　　　　抽象类必须被继承，抽象方法必须被重写

　　　　抽象方法只需声明，无需实现

　　　　抽象类不能被实例化，抽象类不一定要包含抽象方法

　　　　若类中包含抽象方法，给类必须被定义为抽象类

 

　　接口

　　　　接口是抽象类的一种，只包含常量和方法的定义，没有变量和方法的实现，且其方法都是抽象方法。

　　　　用处体现在：

　　　　　　通过接口，实现不相关类的相同行为

　　　　　　通过接口，指明多个类需要实现的方法

　　　　　　通过接口，了解对象的交互界面，无需了解对象所对应的类

 

　　　　接口的定义：

　　　　　　接口声明：

　　　　　　　　[public] interface interfaceName[extends listOfSuperInterface] {...}

　　　　　　方法体定义：

　　　　　　　　returnType methodName([paramlist]);

　　　　接口的实现：

　　　　　　在类的声明中用implements子句来表示一个类使用某个接口

　　　　　　类体中可以使用接口中定义的常量，必须实现接口中定义的所有方法

　　　　　　一个类可以实现多个接口，在implements中用逗号隔开

　　　　接口类型的使用：

　　　　　　接口作为一种引用类型来使用

　　　　　　任何实现该接口的类的实例，都可以存储在该接口类型的变量中，通过这些实例，访问该类接口中的方法。

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------