黑马程序员_类、接口

------- 物联云培训、java培训、期待与您交流！ ----------  

一、面向对象的思想

万事万物皆对象。

比如我，我就是人的一个实例，及人的一个对象。人也可以称为一个对象，人是哺乳动物的一个对象，而哺乳动物又可以是脊柱动物的一个对象，脊柱动物又可以是动物的一个对象……不管是抽象的，还是具体的事物都可以成为一个对象。

二、类和对象的关系

类：就是对事物的描述。

对象：对于这个事物真实存在的个体。

比如说你、我都是人，那么人具体是啥呢？我们就把所有人都具备的特点抽取出来封装在一起，我们就称它为类，你、我为人的对象。

成员变量和局部变量

成员变量作用于整个类中，存放于堆内存中。

局部变量作用于函数中或语句中。存在于栈内存中

三、匿名对象

也就是没有名字的对象

注意：匿名对象调用属性没有意义，因为当在创建下一个对象时，刚才创建的对象没有指向变成了垃圾。

当对对象的方法调用一次时，可以创建匿名对象，这样比较方便。匿名对象可以作为参数传递。

四、面向对象的三个特征

1.      封装：是指隐藏对象的属性和实现细节。

好处：

1>    将变化隔离

比如说：你的手机坏了，你去修时你不用去管怎么修的，只要修好了你用就行了，这就相当于把变化隔离了。

2>    便于使用

比如你的手机会给你留有插口，你用时只要插上就行了，不用去管里边是怎么连接的。

3>    提高重用性

4>    提高安全性

Private：私有，用于修饰类中的成员。私有只在本类中有效。

私有仅仅是封装的一种表现形式

在java语言中只支持单继承。因为例如当多个父类中定义了相同的方法但功能不同时，子类如果继承了父类的话，子类对象不确定要运行哪一个。

继承

组合：手是人的一部分；

聚合：球员是球队的一部分；

      1.继承后字父类中成员的变化

a.变量

当父类与子类中的私有变量相同，用super关键字。Super代表父类对象的引用。This代表的是本类对象的引用；

b.函数

如果父类与子类中的方法一致，会运行子类对象中的方法,相当于重写（覆盖）

当子类不想用父类的功能时，子类可以重写父类中的功能，在子类中建立一个与父类相同的功能名称即可。

如果子类中想在原来的基础上增加新的功能，可以对父类进行重写，但是子类中会重新写一遍父类中原有的功能比较麻烦，这时可以用super，父类中的原有功能。

c.覆盖

1>子类覆盖父类，必须保证子类权限大于父类权限，才可以覆盖，否则编译失败。

2>静态只能覆盖静态。

抽象类中既可以有抽象方法也可以有非抽象的方法。

当多个类中出现了相同功能，但是功能主体不同也可以进行抽取。

这时只抽取功能定义，而不抽取功能主体。

1>抽象方法必须存在于抽象类中。

2>抽象类不可以用new来创建对象。

3>抽象类中的方法要被使用必须由子类复写其所有的抽象方法后建立子类对象，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

4>抽象类和抽象方法必须由abstract修饰          

定义了抽象类，子类必须要重写抽象方法

抽象类不可以实例化

特殊：抽象类中可以不定义抽象方法，这样做的目的是不让该类建立对象。

接口（intorface）

格式：

1>接口中常见定义：常量.抽象方法

2>接口中的成有都有固定的修饰符

常量：public staticfinal

方法：public abstract

接口中的成员都是public的

接口是不可以创建对象的，因为有抽象方法

需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化否则子类是一个抽象类

接口可以被类多实现，也是对多继承转换形式

为什么java中没有多继承？

假如父类中有一个方法与另一个中的方法名相同时，子类会不知道实现哪一个

接口可以实现多继承

3>接口的特点

用于扩张其他的功能

构造函数

给不同的对象进行初始化

在对子类对象初始化时，父类的构造函数也会运行。

那是因为子类的构造函数默认第一行有一条隐式的语句super（）；

Super（）：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）；

构造代码块——>  {

                      // 代码

}

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

和构造函数的区别：

构造代码块给所有的对象进行初始化。

final关键字

1>可以修饰类、函数、变量

2>被final修饰的类不可以继承，为了不让子类重写功能，将类final

3>被final修饰的方法不可以被复写

4>被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

作为常量：常量的书写规范所有字母都大写；如果由多个单词组成，单词间通过_链接

5>内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

this关键字

1>    用于区分局部变量和成员变量重名的情况

2>    this 代表着本类对象就是说那个对象调用this所在的函数this就代表哪个对象

3>    构造函数之间的调用有this关键字例如：this();

4>    this 语句只能放在构造函数的第一行

static 关键字

1>    用于修饰成员（成员变量，成员函数）。

2>    随着类的加载而加载

3>    优先于对象存在

4>    被所有的对象所共享

5>    可以直接被类名调用

6>    静态方法只能访问静态成员

7>    静态方法中不可以定义this、super关键字。

静态代码块——》 static{

静态代码块的执行语句

}

特点：随着类的加载而执行，只执行一次，用于给类进行初始化。优先于主函数。

代码的执行顺序：

静态代码块——>默认初始化——>显示初始化——>构造代码块——>构造函数

2、多态-------主要针对对象的

1>多态的表现形式：父类的引用指向了自己的子类对象

2>多态的前提：必须是类与类之间有关系，要么继承要多实现，存在覆盖

3>多态的好处：大大的提高程序的扩张性

4>多态的应用：

5>多态的弊端：提高了扩张性，但是只能使用父类的引用访问父类中的成员方法

多态的转型

强制将父类的引用，转化成子类类型

例如：Animal a=new Cat（）；

      Cat c=（Cat）a--------向下转型

If( a instanceof Cat)判断a是否是Cat类型

多态中的特点

在多态中成员函数的特点：Fuf=new Zi（）；

在编译时期：参数引用形变量所属的类中是否有调用的方法

如果有，编译通过，否则，编译失败

在运行时期：参阅对象所属的类中是否有相同的方法

指 new Zi（）；

成员函数在多态调用时，编译看左边，运行看右边

在多态中成员变量的特点：

无论编译还是运行都看左边

在多态中，静态成员函数的特点：

无论编译还是运行时期都看左边

Class Fu{
Int i=5;
}
Class Zi extends Fu{
Int i=8;
}
Main(){
Fu f=new Zi();
s.o.p(f.i);--------5
Zi z=new Zi();
s.o.p(z.i);------8
}

五、Object类是所有对象的直接或间接父也就是超类，该类中定义的肯定是所有对象都具备的功能。

Object 类的常用方法：

 (1) public String toString() ：返回对象的字符串表示。

 (2) getClass().getName() + '@' +Integer.toHexString(hashCode())

    它表示的是对象的地址信息,对我们没有意义.所以,一般我们需要重写。

 (3) public final Class<?> getClass() ：返回的是class文件的描述(反射)。

 (4) public int hashCode() ：返回对象的哈希码值。

 (5) protected void finalize() ：当对象没有被引用变量指向的时候，

   jvm 调用此方法进行垃圾回收。

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

    一般来说没有意义。所以，我们也会根据需求重写该方法。

六、内部类

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

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

3>直接访问内部类中的成员，Outer.Innerin=new Outer().new inner()；

4>之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用

格式：外部类名.this

访问格式：

1.当内部类定义在外部类的成员位置上，而且非私有；可以在外部其他类中直接建立内部类对象

2.当内部类在成员上，就可以被成员修饰符所修饰

比如：private：把内部类在外部类中进行封装

Static：内部类就具备了静态的特点

当内部类内static修饰时，内部类只能访问被static修饰的外部成员

在外部其他类中如何访问静态内部类中的静态成员变量呢？

New Outer.Inner().function();

静态成员变量是

Outer.Inner.function();

注意：当内部类定义了静态成员，该内部类必须是静态的

当外部类中的静态方法访问内部类时也必须是静态的

当描述事物时，事物的内部还有事物，该事物用内部类来描述

因为内部事物在调用外部的内容

1>内部类定义在局部时，不可以被成员修饰符修饰

2>可以直接访问外部类中的成员，因为有指向外部类的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量

匿名内部类

1、匿名内部类其实就是内部类的简写格式

2、定义匿名内部类的前提：

内部类必须继承一个类或实现接口

Class Inner extends AbsDemo{
Void show(){
System.out.println(“shouw:”+x);
}
}
New Inner().show()
相当于父类的子类对象
New AbsDmo(){
Voidn show(){
System.out.println(“shouw:”+x);
}
}.show();

匿名内部类的格式：

New 父类或接口（）{定义子类内容}

可以给匿名定义一个名字

AbsDemo d=new AbsDemo(){
void show(){
System.out.println(“shouw:”+x);
}
}
d.show()；

3、匿名内部类中定义的方法最好不要超过3个

七、帮助文档的制作

对文档工具进行提取 javadoc –d 目录。

要生成的帮助文档必须有public修饰。

八、包

1、对类文件进行分类管理

2、javac  –d d:\java20131day\...\javac –d  . packageDemo.java

Javac –d c:\myclass packageDemo.java

Setclasspath=c:\myclass

总结：

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

2>不同包中的子类可以访问父类中被protected权限修饰的成员

包与包之间可以使用的权限只有两种：public、protected

              Public       protected       default         private

同一类中  是                是             是                 是

同一包中  是                是             是                 否

子类         是               是             否                 否

不同包中  是               否             否                 否

为了简化类名的书写，使用一个关键字：import

Import导入的是包中的类

建议不要使用通配符*，需要用到包中的那个类，就导入那个类

------- 物联云培训、java培训、期待与您交流！ ----------