黑马程序员---java基础---2面向对象

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

面向对象：它是一种思想，是相对于面向过程而言！

(1)相对于面向过程而言的一种思想。

面向过程：关注实现问题的过程。

面向对象：关注实现问题的结果。

(2)思想特点：

A:是一种更符合人们思考习惯的思想

B:把复杂的问题简单化了

C:让我们从执行者变成指挥者

案例：把大象装进冰箱！、

把大象装进冰箱面向过程：class Test{public static void main(String[] args){open();in();close();}public static void open(){System.out.println("打开冰箱门");}public static void in(){System.out.println("把大象装进去");}public static void close(){System.out.println("关闭冰箱门");}}面向对象：如何使我们的程序更符合面向对象呢A:分析问题有哪些类B:分析类有哪些成员C:分析类与类的关系class 大象{public void in(){System.out.println("把大象装进去");}}class 冰箱{public void open(){System.out.println("打开冰箱门");}public void close(){System.out.println("关闭冰箱门");}}class Test{public static void main(String[] args){冰箱 b = new 冰箱();b.open();大象 d = new 大象();d.in();b.close();}}

类：类是一类事物的抽象

对象：是该类事物的具体的存在

Car c=new Car（）；在计算机存储方式

 

 

构造方法

(1)作用：通过new调用去创建对象,对对象的内容进行初始化。

(2)格式：

public 类名(参数...)

{

...

}

格式特点：

A:方法名与类名相同

B:没有返回值类型

C:没有返回值

(3)注意事项

A:如果一个类没有给出构造方法，系统会默认给出一个无参构造方法。

B:如果一个类给出了构造方法，系统将不再提供无参构造方法。

这个时候，如果你要使用无参构造方法，只能手动给出。

推荐：任何时刻都自己手动给出无参构造方法。

(4)构造的使用(给成员变量赋值)

class Person

{

private String name;

private int age;

/*

构造代码块。

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

构造代码快中定义的是不同对象共性的初始化内容。

*/{//System.out.println("person code run");cry();}Person(){System.out.println("A: name="+name+",,age="+age);}/**/Person(String n){name = n;System.out.println("B: name="+name+",,age="+age);//cry();}/*public void setName(String n){name  = n;}public String getName(){return name;}*/Person(String n,int a){name = n;age = a;System.out.println("C: name="+name+",,age="+age);//cry();}public void cry(){System.out.println("cry......");}}class  PersonDemo2{public static void main(String[] args) {Person p1 = new Person();Person p2 = new Person("lisi");//System.out.println(p2.getName());//Person p3 = new Person("wnagu",10);}}

成员变量和局部变量的区别

(1)在一个方法中使用一个变量的步骤：

A:在局部范围找

B:在成员范围找

C:报错

(2)区别

A:位置

成员变量在类中，方法外。

局部变量在所属方法中。

B:存储位置

成员变量是随着对象的创建而存在，

随着对象的消失而消失。在堆内存。

局部变量是随着方法的调用而存在，

随着方法的调用完毕而消失。在栈内存。

C:初始化

成员变量有默认值。

局部变量必须先赋值，再使用。

D:作用域

成员变量在类中的所有方法中都可以使用。

局部变量只能在所属的方法中使用。

匿名对象：没有名字的对象。

                    匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。

    如果对一个对象进行多个成员调用，必须给这个对象起个名字。

    匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

封装

(1)隐藏实现细节,提供公共的访问方式

(2)特点：

A:将变化隔离

B:方便使用

C:提高重用性

D:提高安全性

(3)在Java中如何体现：类,函数,还有就是通过private修饰成员变量。

代码体现：private关键字

  A:是一个修饰符。可以修饰成员变量,成员方法。

  B:被私有修饰的内容只能在该类中使用。

  private仅仅是封装的一种体现。

/*

private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。

私有只在本类中有效。

将age私有化以后，类以外即使建立了对象也不能直接访问。

但是人应该有年龄，就需要在Person类中提供对应访问age的方式。

注意：私有仅仅是封装的一种表现形式。

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。

对访问的数据进行操作。提高代码健壮性。

成员变量和局部变量的区别

(1)在一个方法中使用一个变量的步骤：

A:在局部范围找

B:在成员范围找

C:报错

(2)区别

A:位置

成员变量在类中，方法外。

局部变量在所属方法中。

B:存储位置

成员变量是随着对象的创建而存在，

随着对象的消失而消失。在堆内存。

局部变量是随着方法的调用而存在，

随着方法的调用完毕而消失。在栈内存。

C:初始化

成员变量有默认值。

局部变量必须先赋值，再使用。

D:作用域

成员变量在类中的所有方法中都可以使用。

局部变量只能在所属的方法中使用。

匿名对象：没有名字的对象。

                    匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。

    如果对一个对象进行多个成员调用，必须给这个对象起个名字。

    匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

封装

(1)隐藏实现细节,提供公共的访问方式

(2)特点：

A:将变化隔离

B:方便使用

C:提高重用性

D:提高安全性

(3)在Java中如何体现：类,函数,还有就是通过private修饰成员变量。

代码体现：private关键字

  A:是一个修饰符。可以修饰成员变量,成员方法。

  B:被私有修饰的内容只能在该类中使用。

  private仅仅是封装的一种体现。

/*

private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。

私有只在本类中有效。

将age私有化以后，类以外即使建立了对象也不能直接访问。

但是人应该有年龄，就需要在Person类中提供对应访问age的方式。

注意：私有仅仅是封装的一种表现形式。

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。

对访问的数据进行操作。提高代码健壮性。

*/class Person{private int age;public void setAge(int a){if(a>0 && a<130){age = a;speak();}elseSystem.out.println("feifa age");}public int getAge(){return age;}private void speak(){System.out.println("age="+age);}}class PersonDemo{public static void  main(String[] args){Person p = new Person();//p.age = -20;p.setAge(-40);//p.speak();}}

his

(1)代表当前类的一个对象的引用。

(2)this的使用场景：

A:局部变量隐藏成员变量

B:构造方法间相互调用

使用格式：

this.成员变量

this.成员方法()

this(参数) -- 调用本类的其他构造。

this

(1)代表当前类的一个对象的引用。

(2)this的使用场景：

A:局部变量隐藏成员变量

B:构造方法间相互调用

使用格式：

this.成员变量

this.成员方法()

this(参数) -- 调用本类的其他构造。

 

 

class Person{private String private int age;Person(int age){this.age = age;}Person(String name){this.name = name;}Person(String name,int age){this.name = name;this.age = age;}public void speak(){System.out.println("name="+this.name+"...age="+this.age);this.show();}public void show(){System.out.println(this.name);}

static

(1)是一个关键字，可以修饰成员变量和成员方法

(2)特点：

A:随着类的加载而加载。

B:优先于对象存在。

C:被所有对象共享。

D:可以被类名调用。

(3)静态方法和非静态方法的使用

A:静态方法

a:静态成员变量

b:静态成员方法

B:非静态方法

a:非静态成员变量

b:非静态成员方法

c:静态成员变量

d:静态成员方法

(4)静态变量和非静态变量的区别?

A：生命周期

静态随着类的加载而加载，随着类的消失而消失。

非静态随着对象的创建而存在，随着对象的消失而消失。

B：存储位置

静态是存储在方法区中的静态区。(方法区：方法区,静态区,代码区,常量池)

非静态是存在堆中。

C：调用方式

静态可以类名调用，也可以对象名调用。

非静态只能对象名调用。

D：理解不同

静态修饰的内容是被所有对象共享的。

非静态的内容是每个对象特有的。

static

(1)是一个关键字，可以修饰成员变量和成员方法

(2)特点：

A:随着类的加载而加载。

B:优先于对象存在。

C:被所有对象共享。

D:可以被类名调用。

(3)静态方法和非静态方法的使用

A:静态方法

a:静态成员变量

b:静态成员方法

B:非静态方法

a:非静态成员变量

b:非静态成员方法

c:静态成员变量

d:静态成员方法

(4)静态变量和非静态变量的区别?

A：生命周期

静态随着类的加载而加载，随着类的消失而消失。

非静态随着对象的创建而存在，随着对象的消失而消失。

B：存储位置

静态是存储在方法区中的静态区。(方法区：方法区,静态区,代码区,常量池)

非静态是存在堆中。

C：调用方式

静态可以类名调用，也可以对象名调用。

非静态只能对象名调用。

D：理解不同

静态修饰的内容是被所有对象共享的。

非静态的内容是每个对象特有的。

 

 

 

class StaticCode{int num = 9;StaticCode(){System.out.println("b");}static{System.out.println("a");//静态代码块给类初始化}{System.out.println("c"+this.num);//构造代码块，给对象（本类中的）初始化的}StaticCode(int x)//构造函数，给对应对象初始化的{System.out.println("d");}public static void show(){System.out.println("show run");}}class StaticCodeDemo {static{//System.out.println("b");}public static void main(String[] args) {new StaticCode(4);//a c d }static{}}

制作文档

(1)把类文件加入文档注释

(2)使用javadoc命令即可

javadoc -d doc -version -author ArrayTools.java

使用帮助文档(API)

(1)使用步骤

A:打开文档。

B:点击显示 -- 找到索引。

C:知道你要使用的类名。

D:在索引哪里输出类名,回车。

E:看包名

如果是java.lang包，就可以直接使用类。

如果不是java.lang包，就得导入包。

如何导入呢：

格式：

import xxx.xxx.类名;

F:看构造方法

有构造方法：学习构造方法并创建对象。

没有构造方法：它的成员都是静态的。

G:使用功能

通过对象调用方法。

看左边：是否静态，以及返回值类型。

看右边：方法名及参数。

代码块

(1)就是用{}括起来的一段代码

作用：

可以限定代码的作用域,提高效率。

(2)分类：

局部代码块：

在方法中。

作用：尽早的让变量消失，提高效率。

构造代码块：

在成员位置上。

作用：针对多个构造中相同的内容，用它实现。

一般不用。

静态代码块：

在构造代码块上加了static修饰

作用：数据库的连接。只执行一次。

(3)静态代码块,构造代码块,构造方法的执行顺序：

静态代码块 -- > 构造代码块 -- > 构造方法

静态代码块只执行一次，构造代码块每次在构造执行的时候，

都执行。

Person p = new Person()在内存中的执行步骤。(理解)

A:把Person.class加载到内存中。

B:在栈内存给p变量开辟空间。

C:在堆内存给Person对象开辟空间。

D:对成员变量进行默认初始化。

E:对成员变量进行显示初始化。

F:通过构造方法对成员变量进行初始化。

  (如果有构造代码块，先用构造代码块对成员变量初始化)

G:对象才创建完毕。

H:把对象的内存地址值给p变量。

 

继承:把多个类中的共性的内容进行抽取，以后创建类的时候，

   不需要从头开始，可以直接和抽取的类产生一个关系，

   这个关系就是继承。

class Person{String name;int age;}class Student extends Person{void study(){System.out.println("good study");}}class Worker extends Person{void work(){System.out.println("good work");}}class ExtendsDemo {public static void main(String[] args) {Student s = new Student();s.name = "zhagnsan";}}

继承格式：

父类：

class FuClass{}

子类：

class ZiClass extends FuClass{}

好处：

A:提高代码的复用性。

B:让类与类产生了关系，是多态的前

继承特点：

A:java只支持单继承。

B:java支持多层(重)继承。

父类：超类，基类。

子类：派生类。

成员特点：(理解)

A:成员变量

在子类的方法中使用一个变量：

a:在子类局部范围找，有就使用

b:接着在子类成员范围找，有就使用

c:再接着在父类的成员范围找，有就使用

d:报错。

B:构造方法

子类的构造方法执行的时候，会首先去执行

父类的构造方法。

注意：当父类没有无参构造的时候，子类要么

用super调用父类带参数构造，

      要么使用this调用本身的其他构造。

      Object类：是所有类的超类，任何类都直接

      或者间接继承自Object类。

super 代表父类的存储空间。可以使用父类的成员。

成员变量：super.成员变量

成员方法：super.成员方法()

构造方法：super(参数...)

C:成员方法

当子类出现和父类一模一样的方法时，父类的方法就

会被子类覆盖调用。

这种情况被称为方法的重写。(覆盖，重写，复写)

注意：

a:父类私有的方法不能被重写。

b:子类重写父类方法时，访问权限一定要大

于等于父类权限。

c:静态只能重写静态。(不属于对象的范畴)

用子类对象调用方法时：

a:在子类中找方法，有就使用。

b:在父类中找方法，有就使用。

c:报错。

this和super的区别?

this：当前类的对象的引用。

super：父类的存储空间标识。

作用：

this的使用：

this(...)

this.成员变量

this.成员方法()

super的使用：

super(...)

super.成员变量

super.成员方法()

fianl关键字

(1)是一个修饰符，表示最终的意思。

(2)作用：

final:修饰符，表示最终的意思。

它可以修饰类：被修饰的类不能被继承。

它可以修饰成员变量：被修饰的变量就是常量。定义常量。

它可以修饰成员方法：被修饰的方法不能被子类重写。

抽象类

(1)多个类中的方法声明一样，但是方法体不一样，针对这种情况，]

我们只抽取方法声明，

   而只有方法声明没有方法体的方法就是抽象方法。用abstract表示。

   如果一个类中有抽象方法，这个类必须定义为抽象类。

(2)抽象类的特点：

A:一个类中如果有抽象方法，这个类必须定义为抽象类。

  一个抽象类中可以没有抽象方法，这样的类的意义是为

  了不让别人直接创建对象。

B:一个类继承一个抽象类，要么全部实现父类的抽象方法，

要么自己也是抽象类。

C:抽象类不能被实例化。

(3)抽象类的成员特点：

A:成员变量

可以是变量，也可以是常量

B:构造方法

有构造方法，用于子类实例化使用

C:成员方法

可以是抽象方法，也可以是非抽象方法

abstract不能和哪些关键字共存？

final:final修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。

static:static修饰的方法可以直接被类名调用，而调用一个抽象方法没有意义。

private:private修饰的方法不能被重写，而abstract修饰的方法必须被重写，冲突。

模版方法

    在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分， 那么这时就将不确定的                            部分暴露出去。由该类的子类去完成。

 什么是模版方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，

那么这时就将不确定的部分暴露出去。由该类的子类去完成。

接口

(1)当抽象类中的方法都是抽象的时候，java就提供了一种新的表

现形式：接口。

(2)格式：

父接口：

interface Inter

{

}

子类：

class InterImpl implements Inter

{

}

(3)接口的特点：

A:不需要被abstract修饰。

B:类实现接口,可以单实现,还可以多实现。

C:接口可以接口接口,可以单继承，也可以多继承。

(4)抽象类和接口的区别:

A:成员的区别

抽象类：

成员变量：可以是变量，也可以是常量。

构造方法：有构造方法，用于子类实例化使用。

成员方法：可以是抽象的，也可以是非抽象的。

接口：

成员变量：只能是常量。

  默认修饰符：public static final

成员方法：只能是抽象的。

  默认修饰符：public abstract

推荐：默认修饰符请自己永远手动给出。

B:类和接口的关系区别

类与类：

继承关系,只能单继承。可以多层继承。

类与接口：

实现关系,可以单实现,也可以多实现。

类还可以在继承一个类的同时实现多个接口。

接口与接口：

继承关系,可以单继承,也可以多继承。

C:体现的理念不同

抽象类里面定义的都是一个继承体系中的共性内容。

抽象类被继承：is a关系。xx是yy的一种。

接口里面定义的是一个体系的扩展内容。

接口被实现：like a关系。xx像yy的一种。

多态

(1)同一个对象，在不同时刻表现出来的不同状态。

(2)前提：

A:有继承或者实现关系。

B:有方法的重写。

C:有父类(接口)的引用指向子类对象。

(3)多态中的成员使用特点：

父类引用指向子类对象

Fu f = new Zi();

System.out.println(f.num);

f.show();

A:成员变量

编译看左边，运行看左边。

B:成员方法

编译看左边，运行看右边。

(4)多态中的转型：

A:向上转型

把子类对象赋值给父类(接口)的引用

B:向下转型

把父类(接口)的引用强制转换成子类对象

(5)多态的好处及弊端：

A:好处

提高了程序可维护下和可扩展性。

开闭原则：对扩展开放，对修改关闭。

B:弊端

不能使用子类特有内容。

要想使用，要么向下转型，要么重新创建子类对象。

(6)多态的三种形式：

A:具体的类多态

B:抽象类多态

C:接口多态

Object类

(1)是类结构的根类，所有类都直接或者间接的继承自Object类。

(2)方法：

public String toString():返回对象的字符串表示形式。

类名+@+地址值的十六进制

public int hashCode():返回对象的哈希值。

public boolean equals(Object obj):默认比较对象的地址值。

(3)一般，我们会重写一个类的toString()和equals()方法

A:toString():默认的toString()的值没有意义。

B:equals():比较的是地址值，也是没有意义。

例：class Student{private String name;private int age;//...get/setpublic String toString(){//name:null,age:0 -- 默认return "name:"+name+",age:"+age;}//同时比较一个人的名字和年龄是否相同public boolean equals(Object obj){//提高效率if(this == obj){return true;}//提高健壮性if(!(obj instranceof Student)){return false;}//强制类型转换Student s = (Student)obj;return this.age == s.age && this.name.equals(s.name);}}

 

(4)判断一个对象是否是某个类的对象，用instanceof关键字：

格式：对象 instanceof 类名

内部类

(1)把类B定义在类A中，类B就被称为内部类。

(2)为什么要是内部类呢?内部的访问特点

A:内部类可以直接使用外部类成员，包括私有。

B:外部类使用内部类必须创建对象使用。

(3)内部的分类：

成员位置：类一进去就定义类

局部位置：方法内部定义

(4)成员内部类：

class Outer

{

class Inner

{

public void show(){}

}

}

//未用静态修饰或者private修饰。

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

oi.show();

用静态修饰后：

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

oi.show();

一般来说，内部类都会使用private修饰。

(5)局部位置：

匿名内部类：本质是一个对象。

前提：存在这个一个类或者接口。

格式：

new 类或者接口名()

{

重写方法();

};

本质：是继承类或者实现了接口的子类的匿名对象。

一般来说，应该是实现接口，并且，接口中一般都是只有一个方法。

异常

(1)异常：程序出现的非正常情况。

(2)异常体系结构：

Throwable

|--Error 错误,严重的错误。我们处理不了的。

|--Exception 异常。

|--RuntimeException 在运行期间出现的问题，这种情况一般都是改程序。

|--非RuntimeException 编译期间异常,这才是我们需要处理的问题。

举例：

Error:地震了,内存不够,非典

Exception:感冒了,嗓子不好

(3)异常的默认处理方案：

把异常的信息显示在控制台。

包括：异常类名，异常原因，异常的位置。

Throwable的三个方法：

toString():把类名: 异常原因返回。

getMessage():获取异常原因

printStackTrace():打印异常信息

(4)异常的处理方案：

A:try...catch...finally

格式：

try{

可能有问题的代码

}catch(){

解决问题

}finally{

释放资源

}

B:throws throw

throws 异常类名

throw 异常对象名

throws和throw的区别?

A:throws跟在方法后面的，其后跟的是类名。

  throws后面如果是编译期间异常，将来调用的时候，也要抛出或者处理。

  throws后面如果是运行期间异常，将来可以不处理。

B:throw用在方法体中，其后跟的是对象名。

  throw后面如果是编译期间异常，必须在方法上用throws抛出该异常类名。

  throw后面如果是运行期间异常，可以不用throws抛出。

自定义异常

A:创建一个类继承自Exception或者RuntimeException。

B:建议在类中提供一个带参构造方法，调用父亲的带参构造方法。

  将来可以通过getMessage()获取到异常原因

编译期间异常和运行期间异常的区别

A:编译期间异常是必须处理的，否则程序不能通过编译。

  如果把编译期间异常给抛出了，将来还是要处理的。

B:在运行时候才发生的问题，在编译期间是可以不用处理的。

  运行时期的异常，不用处理。

包及导包

(1)包：其实就是文件夹。

   作用：用于区分类以及进行相同类型的类的管理。

   定义包：

package 包名1.包名2...;

(2)带包的编译和运行

A:写代码

B:编译

方案1：手动方法

直接编译

手动建包

把class文件扔到包里面

方式2：自动方法

javac -d . PackageDemo.java

会自动给你创建包，并把class文件扔到这个包里。

C:运行

直接运行，但是需要带类的全路径名

java cn.itcast.PackageDemo

(3)导入包：

import 包名1.包名2....类名;

(4)package,import,class的先后顺序问题

package -- import -- class

 

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ --------------------