黑马程序员_面向对象总结

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


三大特征

封装 （encapsulation）
继承 （inheritance）
多肽 （polymorphism）
object-oriented programming 面向对象程序设计
创建对象的格式：
类名 对象名 = new 类名();
调用成员变量与成员方法的格式：
对象名.成员变量
对象名.成员方法名()成员变量是有初始化值的


成员变量和局部变量的区别：
代码位置：
成员变量：在类中方法外
局部变量：在方法内

内存位置：
成员变量：堆内存中
局部变量：栈内存中
是否有默认值:
成员变量：有默认值
局部变量：没有默认值
使用范围：
成员变量：在整个类中都可以访问
局部变量：只能在该方法中访问
创建时间：
成员变量：随着对象的创建而存在，随着对象的释放而消失 生命周期长
局部变量：随着方法的调用而存在，随着方法使用完毕而消失



变量的使用原则: 就近原则

如果在局部找到了，使用局部变量
如果在类中的成员位置找到了，使用成员变量
如果在类中也没有找到，报错





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

private关键字：
是一个权限修饰符。
用于修饰成员(成员变量和成员函数)
被私有化的成员只在本类中有效
将成员变量私有化，对外提供对应的set ，get方法对其进行访问。
提高对数据访问的安全性

构造函数

特点：
函数名与类名相同
不用定义返回值类型
没有具体的返回值。
作用：
给对象进行初始化
格式：
修饰符 类名(参数列表){}

注意事项：
A:多个构造函数是以重载的形式存在的。

B:如果当前类中没有写构造函数，那么，在程序执行的时候，JVM会自动为当前类添加空参构造函数
如果当前类中写了构造函数，那么，在程序执行的时候，JVM不会为当前类添加空参数构造函数

C:当创建对象的时候，会调用构造函数，给创建出来的对象进行成员初始化的

D:(推荐做法)
定义一个类的时候，为了防止出现构造函数调用的问题，
每定义一个类，就手动的将空参数的构造函数实现


this关键字
（业余版）
代表的是当前对象的引用

（专业版）
特点：this代表其所在函数所属对象的引用。
换言之：this代本类对象的引用
this关键字的使用:
1、当局部变量与成员变量重名的时候，可以使用this关键字来区分
2、在构造函数中使用

格式：this.成员变量

注意：针对成员的修改只对当前对象有效



static关键字的由来
| 多个对象共享同一个属性，使用静态
| 被静态修饰的方法，直接类名调用，方便，不用创建对象



static关键字 的由来

static关键字：
用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用
使用注意
静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的

通过观察结果发现：
非静态的成员变量修改，只对当前对象有效；
而静态的成员变量修改，对所有的对象有效；
所以，可以将所有对象共享的属性定义为 静态的。




在访问的时候：
普通方法调用：
可以调用普通变量，还可以调用 静态变量
可以调用普通方法，也可以调用 静态变量
静态方法调用：
只能调用静态变量
只能调用静态方法

请记住：静态只能访问静态








静态成员与普通成员的区别
位置上的区别
静态成员： 方法区
普通成员： 堆内存
创建时间与销毁消失
静态成员： 随着类的加载而存在，随着类的消失而消失
普通成员： 虽则对象的创建而存在，随着对象的消失而消失
调用上的区别
静态成员： 对象.成员 类名.成员
普通成员： 对象.成员

理解上的区别
静态成员： 多个对象共享同一个属性
普通成员： 每一个对象单独所拥有的



静态代码块
静态代码块 -- 构造代码块 -- 构造函数
运行的特点： 只运行一次
格式 ： static { .... }


API(帮助文档) Application Programming Interface



继承的概述
概念： 在一个已有类的基础上，作为修改，得到一个新的类

继承的特点(子类可以直接访问父类中的非私有的属性和行为)
继承的特点(Java只支持单继承，不支持多继承)
特点：
子类可以直接访问父类中非私有的属性与方法
java中只支持单继承，不支持多继承
java中支持多层(重)继承
成员的特点(成员变量)
变量的就近使用原则
成员变量与局部变量重名，使用 this 关键字
子父类成员重名， 使用 super 关键字
this:  当前对象的引用
super: 父类的引用

成员的特点(成员方法)
方法的重写
概念： 子类将父类的方法重新实现
注意事项：
子类方法的权限 要大于等于 父类方法权限
静态方法 只能覆盖 静态方法
子类不能覆盖父类私有方法





成员的特点：
成员方法：

函数覆盖(函数重写、方法重写)：
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类中的私有方法不可以被覆盖。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
super.方法名 访问父类中的同名方法

注意事项：
覆盖时，子类方法权限一定要大于等于父类方法权限
静态方法只能覆盖静态方法。


请解释下 什么是方法重写、什么是方法重载?
方法重载(Overload)： 在一个类中，方法名相同，参数列表不同
方法重写(Override)： (民间)子类将父类中的 方法 从新实现。
(官方)子类继承父类，子类与父类有同名的方法，子类将父类的方法重新实现。





main方法解析
public: 为了main方法设为最大访问权限
static: 不能创建对象，直接类名调用
void  : main方法是JVM调用的，如果main方法有返回结果，
那么这个结果返回给JVM,我们无法拿到的，所以main设置void类型
main  : JVM只认得main方法， 其他的不认识
String[] : 字符串数组
args  : 字符串数组的名字


作用：静态代码块用来加载驱动的，
      因为驱动只需要加载一次



多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。

class SubDemo extends Demo{}

好处：
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。





math类的演示
(Math.E);
(Math.PI)
字段摘要
static double E
          比任何其他值都更接近 e（即自然对数的底数）的 double 值。
static double PI
          比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。


absolute  绝对值
Math.abs(12.345); 12.345
Math.abs(-12.345); 12.345

ceil天花板  大于等于参数的最小整数
Math.ceil(12.345); 13.0
Math.ceil(-12.345); -12.0

floor  地板  小于等于参数的最大整数
Math.floor(12.345); 12.0
Math.floor(-12.345); -13


max  返回两个数中较大的一个
Math.max(Math.max(123.3, 250.5) , 200.0);


pow  /返回第一个参数的第二个参数次幂的值。


random()   0.0 <= num < 1.0


round  圆  循环 // 四舍五入

sqrt  开平方  /返回正确舍入的 double 值的正平方根。






抽象类的特点：
A: 抽象方法与抽象类必须使用 abstract来修饰
B: 包含抽象方法的类一定是抽象类
C: 抽象类不可以创建对象
D: 继承抽象类的子类，要么声明为抽象类，要么重写父类中所有的抽象方法
E: 抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型   函数名(参数列表) ;

Person
| Girl
| Boy



抽象类中的成员
成员变量：
普通变量
常量



抽象类中的成员
成员方法
普通方法
抽象方法

注意： 抽象类中 可以没有抽象方法
问： 如果一个抽象类中没有抽象方法，那么，为什么要设置为抽象类呢？
答： 防止创建当前类的对象



抽象类中的成员特点
构造函数： 有
问：抽象类不能创建对象，那么，有构造函数有什么用吗？
答：子类创建对象的时候，调用父类构造函数，为父类中成员进行初始化



final关键字
final最终的意思

final可以修饰类，方法，变量。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
final修饰的类不可以被继承。
内部类只能访问被final修饰的局部变量。




定义：某一类事物的多种存在形态

Person
| Girl
| Boy

前提条件：
需要存在继承或者实现关系
要有覆盖操作
父类引用指向子类对象



多态中的成员特点
成员变量：
编译的时候：看的是左边的父类
运行的时候：看的是左边的父类



多态中的成员特点
成员方法：
编译：看左边的父类
运行：看右边的子类



多态中成员的特点
静态成员方法:
编译：看左边的父类
运行：看左边的父类

总结：除了成员方法运行看右边子类以外，都看左边父类



好处和作用：
多态的存在提高了程序的扩展性和后期可维护性

好处：多态的存在提高了程序的扩展性
  后期可维护性(父类 Person 完成的)

弊端：不能使用子类特有方法

Person
| Girl
| Boy
| Other






抽象类相关问题

1、抽象类中是否有构造函数？
有
作用： 子类创建对象时，调用父类构造函数，可以为父类的成员初始化

2、抽象类中可不可以没有抽象方法？如果没有，为什么要定义成抽象类？
可以
防止创建本类对象


3、抽象关键字abstract不可以和哪些关键字共存？
final: 最终的意思，修饰的方法 不能被重写
abstract: 修饰的方法，必须要重写，冲突

private: 私有的意思，修饰的方法，子类不能重写
abstract: 修饰的方法，必须要重写，冲突

static:  静态的意思，修饰的方法，类名直接调用
那么，如果该方法可以设置为抽象
类名.方法名调用，没有意义
abstract:  修饰的方法，必须要重写






发现呢， 抽象类中只有抽象方法，这种时候，在java中，提供 一个新的技术来描述，叫接口
(接口是一个特殊的抽象类)
接口，它不是一个类，所以它没有的默认继承Object类

格式：
interface 接口名{
...
}



接口有了，但是怎么和其他的类 联系起来呢？
我们通过一个技术，实现来让接口与类产生关系 关键字 implements

让类与接口产生关系  实现关系


接口的特点
A: 定义接口使用 interface ， 实现一个接口使用 implements
B: 成员特点：
构造函数：
接口中没有构造函数
成员方法：
只有抽象方法
默认的修饰符: public abstract
成员变量：
只有final 修饰的常量
默认的修饰符： public static final
C: 接口不能直接创建对象
D: 一个类在继承一个类的同时，可以实现多个接口




类与类之间的关系：
继承关系，java中只支持单继承，不支持多继承，但是支持多层(重)继承

类与接口之间的关系：
实现关系，java中支持单实现，也支持多实现

接口与接口之间的关系：
继承关系，java中接口来说，支持单继承，也支持多继承

面试题：
问：java中支持多继承吗？
答：分情况，在一般情况下，java中只支持单继承，但是，接口是一



接口与抽象类的区别？

共  性： 都是不断抽取出来的抽象的概念

区  别：
1、关键字：
接口： interface
抽象类： abstract
2、接口： 实现关系，可以多实现
   抽象类： 继承关系，只能单继承

3、成员的区别
接口：
构造函数：
没有
成员方法：
只有抽象方法

成员变量：
常量

抽象类：
构造函数：
有，子类创建对象的时候，调用父类中构造函数，用来给父类中成员初始化的

成员方法
普通方法
抽象方法

成员变量
普通变量
常量

什么时候使用抽象类？ 什么时候使用接口?

接口: 部分子类必须要做的操作，定义在接口中

抽象类： 所有子类都必须要做的操作，定义在抽象类中





内部类： 类A中有一个类B，类B就叫做内部类


class A{
class B{

}
}

访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。



内部类： 在一个类中，定义另外一个类

根据位置的不同：
成员位置：成员内部类
局部位置：局部内部类

     

外部类
创建内部类对象的格式：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
方式一：

方式二：(推荐)
Outer ou = new Outer();
ou.method();





成员内部类 使用的修饰符
private: 提高数据安全性
static:  方便调用

发现使用static 修饰内部类之后，原先的创建对象方式 不能用了。
新的格式：
外部类名.内部类名 对象名 = new 外部类名.内部类名();



局部内部类

发现内部类 访问外部类的局部位置的变量时，局部位置的变量需要final修饰。
为什么要final修饰呢？

当method方法执行完毕后，变量num就在内存中释放了，
而创建出来的内部类对象，在这个时候成为了垃圾，但是这个垃圾，不会立刻释放出内存
会等到系统空闲的时候，由JVM的自动垃圾回收机制将这个垃圾 清理出内存。
那么，在没有清理出内存的这段时间，这个内部类对象会一直指向着num变量。
而num变量已经释放了，所以会报错。
为了，解决该错误，只能将num 变量的生命周期延长到与类对象相同。
通过 final 关键字来 修饰num 变量，程序就可以使用了


内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。

】


不能被private  static  修饰 因为
1.
因为他本身就是在内部使用的，外部不能访问
2.
所以声明为static的变量实质上就是全局变量。所以static不能修饰局部变量。

静态修饰的内容被所有对象共享，局部变量的作用域只能是所在的函数，而且是在栈内存中存在，当出了作用域就会被释放，根本不能让所以对象共享，而且静态修饰的内容存在于方法区，在内存中和局部变量的存储空间也不一样，所以是不能修饰局部的




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

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

匿名内部类的位置：
如果在成员位置上应该是没法在堆内存中存储 没有名字你怎么存储
而在局部位置直接用了。不用存储
局部位置

匿名内部类格式为：
new 外部类名或者接口名(){
重写父类或者接口的抽象方法
也可以定义特有的方法
};



发现其实匿名内部类就是一个接口或者外部类的子类对象

学习多态的时候，可以讲 父类引用 指向 子类对象





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