黑马程序员_java面向对象学习笔记

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

1：面向对象

(1)面向过程 强调过程，执行者

(2)面向对象 强调对象，指挥者

(3)面向对象思想的特点

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

B：它是复杂的内容简单化

C：它是我们从执行者变成了指挥者

(4)面向对象的特点

A：封装

B：继承

C：多态

2：类和对象

(1)类是对现实世界中事物的描述(属性和方法)

(2)对象是现实世界中实际存在具体的个

把事物转换成java语言描述。而java语言最基本的单位就是类。

把事物对应的属性和行为分别替换成java语言中的成员变量和成员方法。

举例：描述汽车

class Car

{

String color;//属性

int size;

String type;

public void run(){}//方法

public void stop(){}

}

3：局部变量和成员变量

(1)作用范围

局部变量：方法内

成员变量：类中，对整个类有效

(2)存储空间

局部变量：栈内存

成员变量：堆内存

(3)初始化值

局部变量：必须手动给值

成员变量：默认初始化值。

4：匿名对象的使用

(1)当对对象中的功能只执行一次的时候使用。否则，请你使用实名制对象。

Person p = new Person();

p.show();

p.show();

p.print();

new Person().show();

new Person().show();

new Person().print();

(2)用于作为实际参数进行传递。

method(new Person());

public static void method(Person p){}

5：封装

(1)封装的好处：便于重复使用，安全性高。

(2)private权限修饰符

class Demo

{

private int age;

//属性私有化后，我们可以对设置的值进行判断

public void setAge(int age)

{

if(age>100 || age<0)

{

System.out.println("年龄有误");

}

else

{

this.age = age;

}

}

public int getAge()

{

return age;

}

}

6：构造函数

(1)用途：用于创建对象，也有可能要进行初始化。

A：格式 类名(){//code}

B：Person(){}

(2)特点 如果你没有建立构造函数，系统会自动建立一个空参构造，如果你建立了构造函数，系统就不会再建立构造函数了。

(3)重载构造函数

A：Person(){}

B：Person(String name){}

C：Person(int age){}

D：Person(String name,int age){}

注意：构造还可以用于给属性赋值。

7：this关键字

(1)代表当前对象的引用。使用的时候，谁调用方法，this就代表谁。

(2)this的使用：

A：用于局部变量隐藏成员变量。

B：写功能的时候，可能用到this。比如，compare()

C：构造函数中使用this

**this() 必须放在第一行。

举例：

Person(String name)

{

this.name = name;

}

Person(String name,int age)

{

this(name);//是找带一个字符串类型参数的构造方法

this.age = age;

}

8：代码块

(1)局部代码块 提到代码效率

(2)构造代码块 每new一次执行一次。

(3)对象初始化：

Person p = new Person();

在内存中所做的事情：

A：将Person.class文件加载到内存中。

B：在堆内存中创建一个对象Person。

C：把Person中的属性进行默认初始化。

D：把Person中的属性进行显示初始化。

E：调用构造代码块(如果没有，不执行这个操作)。

F：调用构造函数进行初始化。

G：在栈内存中声明Person类型的变量P。

H：把堆内存的地址(引用)赋给了栈内存中P。

9：static关键字

(1)静态的意思。可以修饰类的成员(成员变量和成员方法);

(2)静态成员的特点：

A：随着类的加载而加载，生命周期最长。

B：优先于对象存在。

C：被所有的对象所共享。

D：比非静态成员多了一种访问方式。可以通过类名直接调用。而且建议这样做。

(3)static的使用：

当类中的成员需要被所有对象共享时，用static修饰。不需要被共享时，就不用static修饰。

简单说：共性用static修饰，特性不用static修饰。(例如：饮水机和水杯。)

(4)注意事项

A：静态方法只能访问静态成员的。

B：静态方法中不能使用this,super关键字。

C：main是静态的。

格式如下：

public static void main(String[] args)

{

}

***由于它被jvm调用，所以权限要足够大，所以用public权限修饰符。

***为了jvm可以不用创建对象直接调用它，所以用static修饰。

***void jvm不需要任何返回。但是方法体结尾默认有return;

***main jvm只认识这个名字。

***String[] 有可能需要传入参数。

***args 字符串数组的名字，为了方便使用。

(5)静态代码块

类中加载流程：

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

10：静态的应用

(1)工具类ArrayTool的编译：

因为使用的都是class文件。所以你应该先编译ArrayTool，然后在编译ArrayTest，最后执行ArrayTest。

但是如果引用的工具类特别多的情况下，这样就很麻烦，所以java提供好的方式：只编译ArrayTest即可。

(其实它首先在classpath下找ArrayTool.class，如果没有，接下来在当前类下找ArrayTool.class文件。

如果还没有，它就会找ArrayTool.java文件，并且进行编译。如果都没有，就报错。)

(2) 制作工具说明书:代码中有文档注释,用javadoc解析。

javadoc -d arrayTool -author -version ArrayTool.java

-d 后面跟目录

(3) javadoc: 错误 - 找不到可以文档化的公共或受保护的类。

改用public修饰一下即可

11：API(Application Program Interface)：

应用程序编程接口。

JavaAPI:java的帮助文档。

12：设计模式

java中有23种设计。

单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象：

(1)控制类的创建，不让外部类来创建类的对象。private

(2)在本类中定义一个本来的对象。Student s;

(3)提供公共的访问方式。 public static Student getInstance(){return s}

单例写法两种：

(1)饿汉式 一般开发用这种方式。

class Student

{

private Student(){}

private static Student s = new Student();

public static Student getInstance()

{

return s;

}

}

(2)懒汉式 一般不常用。

class Teacher

{

private Teacher(){}

private static Teacher t;

public static Teacher getInstance()

{

if(t==null)

{

t = new Teacher();

}

return t;

}

}

13：继承(extends)

(1)继承的体系结构：就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

A：先学习顶层内容，因为它是共性内容。

B：一般使用的时候使用的是底层的类。

(2)继承的好处：

A：继承的出现，提高了代码的复用性。

B：继承的出现，让类与类之间产生了关系，extends来表示，

这个关系的出现，为后面我们讲面向对象的第三个特点多态打下了基础。

(3)特点

A：java只支持单继承(其实确切的说是java对多继承进行了优化，避免了安全问题)。

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

(4)注意：

A：子类可以直接访问父类中的非私有的属性和行为。

B：不要仅为了获取其他类中部分功能而去继承。

C：类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

**如何判断A和B是否有继承关系？

**A如果继承B，那么就可以说A是B的一种。

14：继承后子父类之间成员的关系

(1)成员变量

class Father

{

int num1 = 5;

}

class Son extends Father

{

int num1 = 20;

int num2 = 10;

public void show()

{

int num1 = 30;

System.out.println("num1:"+num1);

System.out.println("num2:"+num2);

//局部范围内有的变量，如果我想使用成员变量，用this

System.out.println("this num1:"+this.num1);

//就想子类中访问父类中和子类同名的变量super

System.out.println("father num1:"+super.num1);

}

}

总结：使用子类中的成员变量时，首先看局部有没有和成员变量同名的，如果有就是用局部的。

其实，在子类的成员变量里面找，如果有，直接输出。

最后，在父类中找同名的变量，如果有，就输出父类的值。否则报错。

this和super的区分：

**this代表本类对象的引用

super代表父类的内存空间的标识。

**this可以用于区分局部变量和成员变量同名的情况。

super可以用于区分子类和父类成员变量同名的情况。

**一般，子类中不会出现和父类同名的成员变量。

(2)成员方法

class Father

{

public void show()

{

System.out.println("father show");

}

}

class Son extends Father

{

public void show()

{

System.out.println("son show");

}

public void show1()

{

System.out.println("son show1");

}

}

总结：在使用子类的成员方法时：首先在子类中找，其次在父类中找。否则，报错。

super可以在子类中使用父类的成员方法。

子类中存在和父类成员方法同名的这种现象，叫做重写，复写，覆盖。

重写(override)和重载(overload)的区别：

重载的特点：

**在同一类中。

**方法名相同，参数列表不同。

重写的特点：

**要有继承关系。在子父类中

**方法的声明相同。(方法名和参数列表都相同)

***覆盖时，子类方法权限一定要大于等于父类方法权限

***静态只能覆盖静态。

(3)构造方法

class Father

{

Father(){}

Fahter(int age)

{

System.out.println("father age:"+age);

}

}

class Son extends Father

{

Son()

{

//默认这里有 super();

//this(20);

System.out.println("son");

}

Son(int age)

{

super(age);

System.out.println("son age:"+age);

}

}

Son s = new Son(); //father;son

Son s = new Son(20);//father;son age:20

总结：子类中所有的构造方法默认都会访问父类中空参数的构造方法。

**因为每一个构造方法的第一行都有一条默认的语句super();

当父类中没有空参数的构造方法时，子类的构造函数必须通过this

或者super语句指定要访问的构造方法。类手动提供无参构造方法。

this(...):调用本类中的构造方法

super(...):调用父类中的构造方法

构造方法用于创建对象，并进行初始化。

class Person

{

Person(){}

Person(int age)

{

this.age = age;

}

Person(int age,String name)

{

this(age);

//this.age = age;

this.name = name;

}

}

//Person p =new Person(); //系统默认给出无参构造

//当你手动给出构造方法后，系统就不会再给出默认的空的构造方法。

如果想给属性赋值或者做一些初始化，手动写出无参数构造函数

class Demo

{

private String name;

Demo(){}

public void setName(String name)

{

this.name = name;

}

public String getName()

{

return name;

}

}

15：final可以用来修饰的内容：

(1)final可以用来修饰类：被fainl修饰的类不能被继承。

(2)final可以用来修饰成员方法：被final修饰的成员方法不能被重写。

(3)final可以用来修饰变量：被final修饰的变量为常量，值不能被修改。

常量的命名规范：要求大写。

final int PI = 3.14;

final必须声明的时候就赋值。

一般来说，是这样的。但是特殊情况：在构造方法可以给final修饰的变量赋值。

16：抽象类(abstract)

(1)只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。

(2)抽象类的特点

A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法。

B：抽象类是不能够被实例化的。不能够创建对象的。

C：如果一个类继承抽象类，那么，它要么实现抽象类中的所有抽象方法，

要么本身也是抽象类。

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

A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被实现。

一种是普通的方法。可以被子类直接继承使用。

C：构造方法：抽象类不能被实例化，但抽象类是class，所以它有构造方法。

它的构造方法用于让子类实例化。

(4)抽象类的相关问题：

A：抽象关键字abstract不可以与下面的关键字共存

**private

***私有的，外部直接无法访问。

**static

***那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。

**final

***final修饰的方法不能被重写。所以它和abstract冲突。

C：抽象类中可以没有抽象方法

原因：防止其他类创建该类对象。

17：接口(interface)

(1)接口的由来：当一个类中的方法都是抽象的时候，没必要定义为抽象类，

定义为接口就可以了。

(2)解决了java中只能单继承的问题。(对多继承进行了优化)

A：类与类：只能是单继承。

B：接口与接口：可以是单继承，也可以是多继承。

C：类与接口：可以是单实现，也可以是多实现。

(3)成员特点：

A：只有成员变量和成员方法。

B：成员变量 默认修饰符 public static final

**int x = 20;

**其实是这样的 public static final int x = 20;

C：成员方法 默认修饰符 public abstract

**void show();

**其实是这样的 public abstract void show();

注意：一般情况自己手动加上修饰符。

(4)接口特点：

A：接口是对外暴露的规则

B：接口是功能的扩展

C：接口降低了程序的耦合性。

**内聚(自己实现功能的能力)

**高内聚，低耦合。

D：扩展说了下接口的理解

**狭义的理解就是java中的接口。

**广义的理解就是：任何定义的规范都是接口。

(5)接口和抽象类的区别：

A：抽象类只能被单继承；接口可以被多实现。

B：抽象类中的成员：成员变量:可以是常量，也可以是变量。

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

构造方法:虽然不可以创建对象，但是可以给子类实例化用。

接口中的成员：成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象的。默认修饰符 public abstract

C：抽象类中定义的是体系结构中的共性的内容。

接口中定义的是对象的扩展功能。

D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

接口被实现表示的是: "like a"的关系。xx像yy中的一种。

(6)举例：学生：Student

A：属性：学号,姓名,年龄

B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟

发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。

这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，

我们定义一个接口来放抽烟这个功能。

interface Smoking

{

public abstract void smoking();

}

描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

SmokeStudent ss = new SmokeStudent();

ss.eat();

ss.study();

ss.smoking();

18：多态

(1)某一类事物的多种存在形态。

**方法重载(静态多态)

**方法重写(动态多态,对象多态)

(2)对象多态的前提

A：类与类(或接口)要有继承(或实现)关系。

B：一定要有方法的重写。

C：一定要有父类或者接口的引用指向子类的对象。

(3)多态思想：可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。

A：Animal Cat Dog

**method(Animal a){a.eat();}

(4)多态中成员的特点：

Fu f = new Zi();

A：成员变量：编译和运行都看Fu。

B：非静态方法：编译看Fu，运行看Zi。

C：静态方法：编译和运行都看Fu。

举例： 动物的例子：

向上转型

Animal a = new Cat();

a.eat();

//a.catchMouse();

向下转型

Cat c = (Cat)a;

c.eat();

c.catchMouse();

//向上转型

Animal a = new Dog();

//向下转型 转换异常

//Cat c = (Cat)a;

Dog d = (Dog)a;

孔爹的例子：

孔爹:教课(Java)

孔子:教课(论语),看小说(),打游戏()。

孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了

k.教课(论语)。

//k.看小说();

孔子 kz = (孔子)k;//把衣服脱了

kz.教课(论语);

kz.看小说();

kz.打游戏();

19：Object

(1)Object类：java中所有类的父类。它是java类体系结构中的根类。

java中的类都直接或者间接继承自Object类。

(2)Object里面的几个方法:重点掌握 toString(),equals()。

A：boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。

B：String toString()

返回该对象的字符串表示。

C：int hashCode()

返回该对象的哈希码值。

D：Class<?> getClass()

返回此 Object 的运行时类。

E：protected void finalize() 了解

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

**final,finally,finalize

(3)重点看下面两个方法

//重写toString()方法

public String toString()

{

//return "HelloWorld";

return "name:"+name+",age"+age;

}

//重写Object的equals方法

public boolean equals(Object obj)//s2--obj

{

//为了提高效率

if(this == obj)

{

return true;

}

//为了程序的健壮性

if(!(obj instanceof Student))//格式：对象 instanceof 具体的类名

{

return false;

}

Student s = (Student)obj;

if(this.age==s.age)

{

return true;

}

else

{

return false;

}

}

20：内部类

(1)将类A定义在另一个类B中。则类A就是内部类。

A：什么时候使用内部类：有Outer和Inner两个类，当Inner想要直接访问Outer中的成员，

而Outer需要建立Inner对象来访问Inner中的成员。这个时候，

我们就可以把Inner定义为Outer的内部类。

class Body

{

private class Heart()

{

//调用身体的其他部分

}

}

(2)访问方式：

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

B：而外部类要访问内部类中的成员必须要建立内部类的对象。

(3)内部的存放位置

A：成员位置

**可以被private,static成员修饰符修饰。

**被static修饰的内部类只能访问外部类中的静态成员。

B：局部位置

**也可以直接访问外部类中的成员。

**同时可以访问所在局部中的局部变量，但必须是被final修饰的。

Outer$Inner.class:$表示成员内部类。

Outer$1Inner.class:$1表示它是一个局部内部类。

***因为局部内部类可以不写名字，所以带编号。

(4)匿名内部类：没有名字的内部类。它是内部类的简化写法。

A：前提：内部类可以继承或实现一个外部类或者接口。

B：格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

C：简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

interface Inter

{

public abstract void show1();

public abstract void show2();

}

//局部内部类

class Outer

{

public void method()

{

class Inner implements Inter

{

public void show1()

{

System.out.println("show1");

}

public void show2()

{

System.out.println("show1");

}

}

Inter i = new Inter();

i.show1();

i.show2();

}

}

//局部的匿名内部类(重点)

class Outer

{

public void method()

{

/*new Inter()

{

public void show1()

{

System.out.println("show1");

}

public void show2()

{

System.out.println("show1");

}

}.show1();

new Inter()

{

public void show1()

{

System.out.println("show1");

}

public void show2()

{

System.out.println("show1");

}

}.show2();*/

Inter i = new Inter()

{

public void show1()

{

System.out.println("show1");

}

public void show2()

{

System.out.println("show1");

}

};

i.show1();

i.show2();

}

}

(5)匿名内部类的使用：

A：通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，

可以将匿名内部类作为参数传递。增强阅读性。

21：异常

(1)就是程序运行过程中，遇到了问题，这就叫异常。

(2)异常的体系

Throwable

**Error

***通常出现重大问题如：运行的类不存在或者内存溢出等。

不编写针对代码对其处理。

**Exception

***在运行时运行出现的一些情况，可以通过try catch finally

(3)Throwable

A：getMessage() ：返回此 throwable 的详细消息字符串。

class Throwable

{

String detailMessage;

Throwable(){}

Throwable(String message)

{

this.detailMessage = message;

}

public String getMessage()

{

return detailMessage;

}

}

B：toString()：获取异常类名和异常信息，返回字符串。

C：printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

(4)处理异常处理方式：

A：try...catch...finally

格式：

try

{

需要检测的代码；

}

catch(异常类 变量)

{

异常处理代码；

}

...

finally

{

一定会执行的代码；//释放资源

}

变形：

**try...catch(...)

**try...finally

**try...catch(...)...finally

B：抛出 throws throw

throws:用于标识函数暴露出的异常。thorws用在函数上，后面跟异常类名(可以由多个，用,隔开)。

throw:用于抛出异常对象。throw用在函数内，后面跟异常对象。

C：用哪一个比较合适：

**你能处理，建议处理。try...catch...finally

**你处理不了，抛出。

D：自定义异常

自定义类继承Exception或者其子类(RuntimeException)

class MyException extends Exception

{

MyException(){}

MyException(Stirng message)

{

super(message); //super是Exception里面的

}

}

class Student

{

public void giveAge(int age) throws MyException

{

if(age>40 || age<0)

{

//throw new MyExcetpion("建议不学了");

MyExcepiont my = new MyExcetpion("建议不学了");

throw my;

}

else

{

System.out.println("符号要求，可以学习Java");

}

}

}

E：RuntimeException和Exception

区别：RuntimeException就是要你改代码的。你可以不处理。

22：包

(1)包：package

A：对类文件进行分类管理

B：给类提供多层命名空间

C：放在程序代码的第一行(注释除外)

(2)访问：先得到包，然后:包.类名

如何解决手动创建包：

javac -d xxx PackageDemo.java

-d 后面跟的是：目录

当前目录：.

(3)不同包之间类的访问

类一定要用全路径名称:包名.类名

23：protected

包之间的继承关系。

24：import

简化类名。

一个程序文件中只有一个package，可以有多个import。

用来导包中的类，不导入包中的包。

25：权限修饰符

同一个类中 同一个包中 不同包中子类中 不同包中，不存在继承关系

private OK

默认 OK Ok

protected Ok Ok Ok

public OK Ok OK OK

26：关键字用来修饰：

类 属性 方法 构造方法

private OK OK OK

默认 OK Ok Ok OK

protected Ok Ok OK

public Ok Ok Ok OK

static Ok Ok

final Ok Ok Ok

abstract Ok Ok

特殊：private和static可以修饰内部类。

static可以代码块。静态代码块。

A：权限修饰符任意时刻只能使用一种。

B：static,private,final 不能和abstract并用。

27：jar

(1)打包：

jar -cf haha.jar packa

(2)查看jar包

jar -xvf haha.jar

(3)如果内容特别多，好几个屏幕都放不下，

假使我们能够通过某个命令，讲这些目录写入到一个记事本中。看起来就方便了。

jar -tf haha.jar > c:\a.txt