----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
面向对象构造方法、抽象类、内部类
一、面向对象构造方法
构造器 又称为构造方法 ，constructor
构造器用于构造该类的实例。作用：用来初始化对象！
代码：
[修饰符] 类名 （形式参数列表）{
//语句
}
是一种特殊的方法：
（1）通过new关键字调用！！
（2）构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能再构造器里调用 return。
（3）如果我们没有定义构造器，则系统会自动定义一个无参数的构造函数，如果已经定义则编译器不会添加，覆盖了系统默认的构造方法。
（4）构造器的方法名必须和类名一致。
（5） 构造该类的对象，经常用来初始化对象的属性。
1.构造方法必须与类名保持一致，
2.无返回类型
3.通过new来调用
4.无参构造函数问题：
a)如果我们没有定义构造器，则系统会自动定义一个无参数的构造函数
b)如果已经定义则编译器不会添加
5.构造方法的第一句总是super，即调用直接父类的构造方法
a)有继承关系的构造方法调用的顺序
对象一建立就会调用与之对应的构造函数，new几次 就会调用几次。
构造函数和一般方法在运行上的不同：
构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能
一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。构造函数与set。get方法应同时存在，构造函数是给对象初始化，set、get方法是对外提供的公共方法。
什么时候 定义构造函数？
分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块：
{
语句
}
作用，给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
与构造函数的区别：
构造代码块是给所有对象进行统一初始化，定义的是不同对象共性的初始化内筒。构造函数是给对应的对象初始化。
二、抽象类
抽象类：abstract。
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。分析事物不确定时，就抽象
特点
1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰
3.抽象类不可以用new 创建对象，因为创建对象没有意义
4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。
抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。
抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。
抽象类可以包含 普通方法 成员变量 构造方法
例子：
abstract class enmployee{
private String name;
private int id;
private double money;
public enmployee(String name, int id, double money) {
super();
this.name = name;
this.id = id;
this.money = money;
}
public abstract void work();
}
class yuangong extends enmployee{
public yuangong(String name, int id, double money) {
super(name, id, money);
}
public void work(){
//员工工作
}
}
class jingli extends enmployee{
double jiangjin;
public jingli(String name, int id, double money,double jiangjin) {
super(name, id, money);
this.jiangjin=jiangjin;
}
public void work(){
//经理工作
}
}
模板方法模式：
在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分
在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。
案例：
/*
- 获取一段程序的运行时间
/
abstract class GetTime
{
public final void gettime()
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println(end-start);
}
public abstract void runcode();
}
class Subtime extends GetTime{
public void runcode(){
for(int x=0;x<1000;x++){
System.out.println(x);
}
}
}
三、内部类
内部类
讲一个雷定义在另一个类的里面，对立面那个类就叫做内部类，或者嵌套类。
特点，内部类可以直接访问外部类中的成员。包括私有成员。而外部类要访问内部类中的成员必须要建立内部类对象。
代码
class outer
class inner
void function(){}
}
}
inner内部类。
访问规则：
1.内部类可以直接访问外部类中的成员，包括私有。是因为内部类中持有了一个外部类的引用。格式：外部类名.this
2.外部类要访问内部类，必须要建立内部类的对象。
3.内部类作为外部类的成员 可以被私有化
如何直接访问内部类中的成员 function()
outer.inner in=new outer().inner();
in.function();
访问格式：
1.当内部类定义在外部类的位置上的时候，而且非私有，可以在外部其他类中，可以直接建立内部类对象
格式 外部类名.内部类名 变量名=外部类对象.内部类对象
outer.inner in=new outer().inner();
2.当内部类在成员的位置上，就可以被成员修饰符所修饰。
比如：private static，
当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限
在外部其他类中，如何直接访问static内部类的非静态成员？
new Outer.Inner().sunction();
在外部其他类中，如何直接访问staic内部类的静态成员？
outer.inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static 的。
当外部类中的静态方法访问内部类是，该内部类必须是静态的
内部类定义原则：
当描述事物中，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物中的内容。
局部内部类
class outer{
int x=3;
void method()
{
int y=4;
class inner{
void function(){}
}
}
}
内部类定义在局部的时候：
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类中的引用
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
方法中的内部类能不能访问方法中的局部变量，为什么？
/* 说明下此程序在内存中的执行过程，就可以了解 为什么方法中的内部类不能访问方法中的局部变量。
首先JVM找到主函数的入口， 在栈中就开辟了一个main方法的空间 同时 创建了一个 变量o,同时在堆内存中 new Outer()分配了一块内存空间，然后将变量O的引用就指向了该内存空间。Outer o=new Outer();
这就话就执行完毕，在调用function的方法时，就会将方法区中的funtion()方法进入栈中，同时将x=4 加载进栈内存中。如果不将x设置为final ，执行完, o.function();就会将function方法弹栈，此时局部x也就不存在，
内部了也是一个类，在创建一个改局部类的对象之后，只有没有其他变量引用它，它才会变成垃圾，并且在不定时消失所以可能发生的情况是 ：在局部变量消失之后，内部类的对象还存活。也就是说在执行 内部类add()方法的时候x已经 不存在了。所以，方法中的内部类不能访问方法中的局部变量。
解决办法 就是将x 前加final 变成该内部类inner对象中的一个数据成员。这样，即使栈中局部变量x已消失， 但由于它是final,其值永不变，因而局部内部类对象在变量x死亡后，照样可以访问final型局部变量。
*/
class Outer{
void function()
{
final int x=4;//方法的局部变量
//内部类
class Inner{
//内部类的方法
void add()
{
System.out.print(x+4); //调用外部类方法中的局部变量
}
}
new Inner().add();//创建个内部类的对象
}
}
public class Test2 {
public static void main(String[] args) {
Outer o=new Outer();//创建外部类对象并将 o的引用指向该变量的地址
o.function();//
}
}
