JAVA4 封装继承抽象类接口多态

封装：

成员变量：生存期随对象，作用范围类内

局部变量：生存期局部，作用范围局部

构造函数有个构造代码块 初始化对象时在类中先于构造函数运行，一般它包含各个构造函数的公共部分

class a

{

a(){}

{

构造代码块

}

}

this关键字：

1用于类中定义有重名变量

2用于构造函数间互相调用

如：

class a

{

int age;

a(){};

a(int age)

{

this.a();//这里不能写成a.a(),并且必须在这个函数块的开始部分，因为初始化工作必须在前

this.age = age;
}

}

有个东西叫做静态代码块:

static

{
}

继承：

java中任何类都会继承一个叫object的类

class A

{

int n = 4;

}

class B extends A

{

}

B b = new B(); 这里会继承n 并且值为4

class A

{

int n = 4;

}

class B extends A

{

int n = 5;

void show()

{

System.out.println(super.n);System.out.println(this.n);

}

}

B b = new B(); 这里会打印4 5 继承并且有子类和父类的n

如果子类中不写n=5那么会打印4 4 ,这里应该是因为内存中this super指向一个地方了

如果父类中谢了private int n = 4 子类中调用super.n会编译出错

继承是函数会覆盖，子类函数实现时可在内部用super来调用父类

用子类构造对象时，会先调用父类初始化函数来初始化子类从父类继承的变量

final关键字：

一般修饰类，函数，变量。

修饰类时类就不能被继承了，修饰函数时函数不能被重写了，修饰变量是变量不能被改变了。

抽象类：

抽象类中必有一个抽象函数。

接口：

接口中一般有这样的两类变量：

public static final int a = 3;

public abstract void show();

类继承类用extends  这时子类中的类可以自己定义类型，但只能更开放eg从private到默认到public

类继承接口用implements  这时子类中的函数必须加public，因为接口中函数默认为public，子类中必须更开放或持平

Java 不支持多继承，但是可以继承多个接口

多态：

B继承A ，B b

这时b instanceof B 对， b instanceof A 也对

abstract class F

{

static int s;

static void show ();

int a 

abstract void do();

}

class Z extends F

{

}

F f = new Z();

使用f .show()或者f.s或者f.a之接调用父类中的，静态绑定

使用f.do()将调用子类中的，动态绑定

注意点：f.function();如果父类中没有function，而子类中有function，这个调用是否可以呢？行，编译过。

多态应用：

interface Inter

{

}

class useInter

{

void doSome(Inter i);

}

class a extends Inter

{
}

class b extends Inter

{
}

class c extends Inter

{
}

这样有Inter和useInter即可，其他的随时实现接口即可

包含类：

内部类可以直接访问外部类中的成员，包括私有

外部类访问内部类必须建立内部对象

这里注意：内部类的前面可以加private了，普通的类前只能空或public

class Outer

{

private int x = 3;

class Inner

{

private int x = 4;

void function()

{

// int x = 5;

System.out.println("inner:"+x);//这里先找局部是否有x,再找内部类中是否有即this.x，再找外部类中是否有Outer.this.x(内部类持有了外部类的引用，格式外部类.this)

}

}

void method()

{

Inner in = new Inner();

in.function();

}
}

Outer out = new Outer();

 out.method();

内部类前无private时，直接访问内部类中的成员：

Outer.Inner in = new Outer.new Inner();

in.function();

内部类前加private修饰，就被封装了

内部类前加static时，只能直接访问外部类中的静态成员了。

 内部类中定义静态成员时，那么该内部类必须为静态。

外部类的静态方法可以调用静态内部类的方法，但不能定义非静态类的方法（静动都可，但是用方法有差别，掉非静时用new)

内部类设计：

class body

{

private class heart

{
}

void show()

{

new heart()
}

}