面向对象核心技术

类的继承

只支持单继承、即一个子类只能继承一个父类

child extends parents

重写父类

重写时不能降低方法的修饰权限范围，父类的protected可以改为public ，但不能private

parents a=new child();
//父类声明，子类实现
child a=new parents();//这是错误的

super关键字

super.property;//调用父类属性
super.method();//调用父类的方法

getClass()
返回对象执行时的Class实例，getName取得类的名称

System.out.println(b.getClass().getName());
=>xiaoxiong1.Computer2

System.out.println(b.getClass());
=>class xiaoxiong1.Computer2

System.out.println(new Computer2());
=>xiaoxiong1.Computer2@15db9742

多态

重载

参数个数不同、参数类型不同、参数顺序不同

return (int) (a+b);
//输出为int型

向上转型：
将子类对象看作是父类对象
向下转型：
将父类对象赋予子类对象，并强制转换为子类型

parents a=new child();
child b=(child) a;

instanceof关键字

当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生Class否为CastException异常，所以在执行向下转型之前需要养成个良好的习惯， 就是判断父类对象是否为子类对象的实例。这个判断通常使用instanceof操作符来完成
用它来判断个实例对象是否属于一个类。

if (q instanceof Square) {
	Square s = (Square) q; // 进行向下转型操作
}

抽象类与接口

abstract关键字
构造方法不能定义为抽象方法

public abstract class Market {
	public String name;//商场名称
    public String goods;//商品名称
    public abstract void shop();//抽象方法，用来输出信息
}

public class TaobaoMarket extends Market {
    @Override
	public void shop() {
		// TODO Auto-generated method stub
		System.out.println(name+"网购"+goods);
	}
}

接口

interface关键字

interface drawTest { // 定义接口
	public void draw(); // 定义方法
}

一个类实现一个接口用implements关键字

class ParallelogramgleUseInterface implements drawTest {
	public void draw() { // 由于该类实现了接口，所以需要覆盖draw()方法
		System.out.println("平行四边形.draw()");
	}
}

class me implements IFather,IMother;
//多个接口对象，用,隔开

接口中的方法都是抽象的，因此，当子类实现接口时，必须实现接口中的所有方法
多重继承
如果是接口继承接口，使用extends关键字

interface intf1{
    void a();
}
interface intf2 extends intf1{
    void b();
}
public class intf3 implements intf2{//实现子接口，但必须重写所有方法
    public void a(){
    }
    public void b(){
    }
}    

(1)子类只能继承一个抽象类，但可以实现任意多个接口。
(2)一个类要实现一个接口必须实现接口中的所有方法，而抽象类不必。
(3)抽象类中的成员变量可以是各种类型，而接口中的成员变量只能是public static final的(4)接口中只能定义抽象方法，而抽象类中可以定义非抽象方法。
(5)抽象类中可以有静态方法和静态代码块等，接口中不可以。
(6)接口不能被实例化，没有构造方法，但抽象类可以有构造方法。

访问控制

不使用public修饰符设置类的权限，则默认为default（缺省）修饰，本类、本类所在包可见；其他包中的子类、其他包中的非子类不可见

import xiaoxiong.*;     //指定包中所有类在程序中可使用
import xiaoxiong.Math  //指定包中Math类在程序中可使用

final关键字

不能被继承、不能改动、不能覆盖

final double PI=3.14;

也不是恒定不变

private static Random rand = new Random();
private final int a1 = rand.nextInt(10);
//每次运行随机产生0~10之间的随机数赋予定义为final的a1

private static final int a2 = rand.nextInt(10);
//static 不变化

通常使用public static final修饰，这样的常量只能在定义时被赋值

内部类

public class OutClass{  //外部类
	private class InnerClass{  //内部类
		
	}
}

内部类可以使用外部类的成员

外部类不可以直接访问内部成员变量

非内部类不能被声明为private或protected访问类型

使用this关键字获取内部类与外部类的引用

public class TheSameName {
	private int x;
	private class Inner {
		private int x = 9;
		public void doit(int x) {
			x++; 					//调用的是形参x
			this.x++; 					//调用内部类的变量x
			TheSameName.this.x++; 	//调用外部类的变量x
		}
	}
}

局部内部类

interface OutInterface2 { // 定义一个接口
}
class OuterClass3 {
	public OutInterface2 doit(final String x) { // doit()方法参数为final类型
		// 在doit()方法中定义一个内部类
		class InnerClass2 implements OutInterface2 {
			InnerClass2(String s) {
				s = x;
				System.out.println(s);
			}
		}
		return new InnerClass2("doit");
	}
}

匿名内部类

return new A(){
    //.....
};

interface OutInterface2 { // 定义一个接口
}

class OuterClass4 {
	public OutInterface2 doit() { // 定义doit()方法
		return new OutInterface2() { // 声明匿名内部类
			private int i = 0;
			public int getValue() {
				return i;
			}
		};
	}
}

(1)匿名类没有构造方法;
(2)匿名类不能定义静态的成员;
(3)匿名类不能用private. public. protected、 static. final. abstact 等修饰;
(4)只可以创建一个匿名类实例。

静态内部类

不能使用外部类的非静态成员，如果创建静态内部类的对象，不需要创建其外部类的对象

public class StaticInnerClass {
	int x = 100;

	static class Inner {
		void doitInner() {
			// System.out.println("外部类"+x);
			//不能调用外部类的成员变量x
		}

		public static void main(String args[]) {
			System.out.println();
		}
	}
}

内部类的继承

public class OutputInnerClass extends ClassA.ClassB { // 继承内部类ClassB
	public OutputInnerClass(ClassA a) {
		a.super();
	}
}

class ClassA {
	class ClassB {
	}
}

在某个类继承内部类时，必须硬性给予这个类一个带 多数的构造方法，并且该构造方法的参数必须是该内部类的外部类引用，就像例子中的ClassA a,同时在构造方法体中使用a。super()语句。