JAVA 面向对象基础
面向对象
封装的原则
要求使对象之外的部分不能随意存取对象的内部数据，从而有效避免了错误对它的“交叉感染”，使软件错误能局部化，降低排错难度
继承
所有的类都继承自 java.lang.Object，一些常用的方法：
equals():比较两个对象引用时否相同。
getClass():返回对象运行时所对应的类的表示，从而得到相应的信息
toString():返回对象字符串表示
finalize():用于在垃圾收集前清除对象
notify(), notifyall(), wait(): 用于多线程处理中的同步
子类（subclass）对父类（superclass，超类）的继承
子类不能继承父类中访问权限为 private 的成员变量和方法。
子类可以重写父类的方法，及命名与父类同名的成员变量。
Java 不支持多重继承
创建子类
class SubClass extends SuperClass {
...
}成员的隐藏和方法的重写
子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为变为自身的状态和行为。
多态性
子类继承父类后，同一个方法有不同的表现
体现在两个方面：方法重载实现的静态多态性（编译时多态），方法重写实现的动态多态性（运行时多态）
重写方法的调用原则：子类重写父类的方法，调用子类方法；反之，调用父类的方法
一个对象可以引用子类的实例来调用子类的方法
eg: B 继承 A，A 的对象 a 引用 B 的实例，调用 B 的方法 callme()
import java.io.*;
class A {
void callme() {
System.out.println("Inside A's callme()) method");
}
}
class B extends A {
void callme() {
System.out.println("Inside B's callme() method");
}
}
public class Dispatch {
public static void main(String args[]) {
A a = new B(); // 引用子类的实例
a.callme();
}
}
类的实现
类声明
[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]);
eg:
import java.io.*;
class SuperClass {
int x;
SuperClass() {
x = 3;
System.out.println("in SuperClass: x = " + x);
}
void doSomething() {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass {
int x;
SubClass() {
super();
x = 5;
System.out.println("in SubClass: x = " + x);
}
void doSomething() {
super.doSomething();
System.out.println("in SubClass.doSomething()");
System.out.println("Super.x = " + super.x + "sub.x = " + x);
}
}
public class Inhereritance {
public static void main(String chars[]) {
SubClass sc = new SubClass();
sc.doSomething();
}
}
简单数据：值类型
复合数据：引用类型
import java.io.*;
public class PassTest {
float ptValue;
public static void main(String args[]) {
int val;
PassTest pt = new PassTest();
val = 11;
System.out.println("Original int Value is:"+val);
pt.changeInt(val);
System.out.println("Int Value after Change is:"+val);
pt.ptValue = 101f;
System.out.println("Original ptValue is:"+pt.ptValue);
pt.changeObjectValue(pt); // 引用类型的参数
System.out.println("ptValue after change is:"+pt.ptValue);
}
public void changeInt(int value) {
value = 55;
}
public void changeObjectValue(PassTest ref) {
ref.ptValue = 99f;
}
}
简单数据类型作为参数传递时，为值传递；复合数据类型作为参数传递时，为地址传递
方法体 方法的实现。方法体中局部变量若与成员变量同名，局部变量将屏蔽成员变量。
import java.io.*;
class Variable {
int x = 0, y = 0, z = 0; // 类的成员变量
void init(int x, int y) {
this.x = x;
this.y = y;
int z = 5; // 局部变量
System.out.println("** in init**");
System.out.println("x = " + x + "y = " + y + "z = " + z);
}
}
public class VariableTest {
public static void main(String args[]) {
Variable v = new Variable();
System.out.println("** before init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
v.init(20, 30);
System.out.println("** after init **");
System.out.println("x = " + v.x + "y = " + v.y + "z = " + v.z);
}
}
方法重载
指多个方法享有相同的名字。这些方法的参数必须不同。且参数类型区分度要足够：如不能使同一简单类型的数据：int 与 long