黑马程序员_面向对象部分

----------------------android培训、java培训、期待与您交流！ ----------------------



以前接触过面向对象部分，但是基础不牢，以下仅为自己不熟悉的知识点。



1.成员变量：成员变量定义在类中，在整个类中都可以被访问。成员变量随着对象的建立而建立，存在于对象所在的堆内存中。 成员变量有默认初始化值。

局部变量：局部变量只定义在局部范围内，如：函数内，语句内等。局部变量存在于栈内存中。作用的范围结束，变量空间会自动释放。局部变量没有默认初始化值。

2. 封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima封装原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏，提供公共方法对其访问。

3.初始化块优先于构造器运行。

4.同一类中构造函数之间的调用只能用this，且必须放在第一行。如：this(“name ”,35);

当同一类中的方法互相调用时，非静态方法省略的是this，静态方法中省略的是类名。

5.主函数的传入参数args名字可以更改。

6.static的一个作用是功能封装工具类。

7.帮助文档写法：

/**

这里定义帮助文档内容。通常有一些自动标记：

@author 定义作者

@version 定义版本号

@param 定义输入参数 当有多个传入参数时，可以定义多个@param标记

@return 定义返回值

*/

例如：

/**

* 帮助文档示例

* @author 王五

* @version 1.0

* */

public class Demo {

/**

* 获取参数的最大值

* @param arr 接受一个int 型的数组

* @return 返回数组中的最大值

* */

public static int getMax(int []arr){

int max=0;

//代码省略

return max;

}

}

命令行输入生成：javadoc -d helpDemo -author -version Demo.java

其中：

a. -d表示生成目录，后面跟目录名。加入没有目录名，则-d后面的参数会被当做目录名。当需要生成作者和版本时，需要-author –version参数。

b. 要生成帮助文档的类必须是public修饰的类。

c. 私有权限文档不会生成。只有protected和publc权限会生成保护文档。

d. 构造器文档的生成规则同方法。

e. 当没有定义构造器时，会有默认是构造器。权限同类的权限。

8.静态代码块只执行一次，随着类的加载而执行，如果这函数所在的类有静态代码块，他会优先于主函数执行。代码块执行顺序：静态的模块>动态代码块>构造器中的代码。

9. Person p=new Person(“name”, 24):执行顺序：加载Person类、执行相应的代码块、在对内存中分配地址，建立相应对象属性性、默认初始化、显示初始化、构造函数初始化、将内存地址付给变量。Person p=null；只是单纯的定义一个变量，不加载Person类。

10.单例模式：

饿汉式(Demo类一进内存，d就已经初始化)：

public class Demo {

static Demo d=new Demo();

int x=9;

private Demo(){System.out.println("c");}

public int getX() { return x; }

public void setX(int x) { this.x = x;}

public static Demo getInstance (){ return d; }



public static void main(String []a){

Demo d1=Demo. getInstance ();

Demo d2=Demo. getInstance ();

d1.setX(10);

System.out.println(d2.getX()); }}

懒汉式(Demo类一进内存，d就没有初始化，当调用getInstance方法是才初始化对象)：

public class Demo {

static Demo d=null;

int x=9;

private Demo(){System.out.println("c");}

public int getX() { return x; }

public void setX(int x) { this.x = x;}

public static Demo getInstance (){

if(d==null)

d=new Demo();

return d; }



public static void main(String []a){

Demo d1=Demo. getInstance ();

Demo d2=Demo. getInstance ();

d1.setX(10);

System.out.println(d2.getX()); }}

编程时常用饿汉式，因为如果没加锁时，懒汉式在多线程中应用时，可能发生故障。但是加锁时，程序效率会变低。

假如一定要用懒汉式时，解决方法如下：

public class Demo {

static Demo d=null;

int x=9;

private Demo(){System.out.println("c");}

public int getX() { return x; }

public void setX(int x) { this.x = x;}

public static Demo getInstance (){

if(d==null){

synchronized(Demo.class){

if(d==null)

d=new Demo();}}

return d; }



public static void main(String []a){

Demo d1=Demo. getInstance ();

Demo d2=Demo. getInstance ();

d1.setX(10);

System.out.println(d2.getX()); }}

但是，用此种方法时，代码变多，所以，在开发中建议用饿汉式。

11.重写，即子类和父类函数同名。

12.当子类和父类属性同名时，要在子类中调用父类的属性，要用supper关键字。

13.抽象类不可以用new创建对象。抽象类和抽象方法必须用abstract修饰。

14.模板设计模式：在第一功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分那么这时可以将不确定的部分抽象成一个方法暴露出去，让子类重写。

例（确定一段代码的运行时间）：

public class Demo2 extends GetTime{

public static void main(String agrs[]) {

new Demo2().getTime();

}

void runCode() {

for(int i=0;i<10000000;i++){ }

System.out.println(); }}

abstract class GetTime{

public final void getTime(){

long start=System.currentTimeMillis();

runCode();

long end=System.currentTimeMillis();

System.out.println("运行时间："+(end-start)); }

abstract void runCode();}

15.接口中的常量全部是public static final 类型的，方法的修饰词全部是public abstract。这些些修饰可以省略，当省略是，编译器默认添加。接口与接口间可以继承，而且可以多继承，一般不用这种模式。

16.多态中方法的特点：父类变量指向子类的引用时，父类可以强制转换成子类。当没有转换成子类引用时，父类变量不能调用子类方法。父类变量指向父类引用时，不能强制转换成子类。对于非静态方法，当子类重写父类方法时，多态调用此方法时，运行子类的重写方法，此叫动态绑定。而静态方法时，运行的是父类方法，此叫静态绑定。

例：

public class Demo2 {

public static void main(String agrs[]) {

//假设Animal不是抽象类，并有Animal a=new Animal();时，a不可以转换成子类。

Animal a=new Dog();

Animal b=new Fish();

a.run();//狗跑

b.run();//鱼游

((Dog)a).eat();//狗吃骨头

// a.eat(); 错误

//当在if else语句中用instanceof判断对象的类型时，应该先判断对象是否是

//类对象，再判断是否是父类对象。

System.out.println(a instanceof Dog);// true

System.out.println(a instanceof Animal);// true

System.out.println(a instanceof Fish);// false

}

}

abstract class Animal{

abstract void run();

}

class Dog extends Animal{

@Override

void run() {

System.out.println("狗跑");

}

void eat(){

System.out.println("狗吃骨头");

}

}

class Fish extends Animal{

@Override

void run() {

System.out.println("鱼游");

}

void eat(){

System.out.println("鱼吃虾");

}

}

17，多态中变量的特点：父类与子类变量同名，父类对象指向子类应用，当“对象.变量”时，访问的是父类的数据。

18.接口引用指向子类对象也存在多态。

19.接口的可以降低类与类之间的耦合性。毕向东8-6 8-7

20.内部类规则：

A. 内部类可以直接访问外部类成员，包括私有。

B．外部类访问内部类必须创建对象。

C．可以创建内部类对象访问内部类，但是创建时必须使用全称，即Outer.Inner demo=new Outer().new Inner()。但是，通常内部类都会私有修饰，不允许创建对象。除了内部类外，其他类不可以被私有修饰。

D．变量访问规则:

class Outer{

int x=1;

class Inner{

int x=2;

void f(){

int x=3;

System.out.println(x);//打印 3

System.out.println(this.x);//打印 2

System.out.println(Outer.this.x);//打印 1

}

}

}

E．当一个类可以直接访问一个类的成员时，可以把它封装成私有内部类，然后在外部类中提供方法，在方法中访问内部类，再把方法暴露给外界使用。

F.内部类可以定义在外部类的任何地方，包括方法内，此时，内部类不能静态修饰。访问规则不变。

G．当内部类定义在局部时，不可以被成员修饰符修饰，即public 、private、 protected，但是可以被abstract，final修饰。可以直接访问外部类的成员及变量，但是访问所在局部的局部变量(包括方法中传入参数，但是传入参数可以是void f(final int x)的形式)时，局部变量必须定义为最终类型。

I.内部类中可以定义自己的方法。

J.父类或父接口可以指向匿名内部类，但是此时匿名内部类中能定义自己独有的方法。但是，一般不建议这样做。

K.Object类是任何类的父类，所以可以通过new Object(){};的方式创建任何匿名内部类(面试题)。

L．非静态内部类中不可以定义静态成员。

21.子类构造器第一行默认调用父类无参构造器，即super().子类至少有一个构造器访问父类无参构造器。构造器中this和super都必须放在第一行。

22.final修饰的类不可以被继承。final修饰的方法不可以被重写(重载发生在同一个类中)。final修饰的变量值不能改变。

23.普通类只可以被public, abstract & final修饰。

24. import 导入的是包中的类。建议，不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。运用通配符时，会导入包内所有的类。

25.权限：

public protected default private

同一个类中 ok ok ok ok

同一个包中 ok ok ok

子类 ok ok

不同包中 ok

26. 包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima