java面向对象的注意点1

面向对象思想特点：

　　　　* a:是一种更符合我们思想习惯的思想
　　　　* b:可以将复杂的事情简单化
　　　　* c:将我们从执行者变成了指挥者
　　　　* 角色发生了转换

面向对象开发,设计以及特征：

　　　　* A:面向对象开发
　　　　* 就是不断的创建对象，使用对象，指挥对象做事情。
　　　　* B:面向对象设计
　　　　* 其实就是在管理和维护对象之间的关系。
　　　　* C:面向对象特征
　　　　* 封装(encapsulation)
　　　　* 继承(inheritance)
　　　　* 多态(polymorphism)

类和对象的概念：

　　　　* a:类：是一组相关的属性和行为的集合
　　　　* b:对象：是该类事物的具体体现
　　　　* c:举例：
　　　　* 类 学生
　　　　* 对象 具体的某个学生就是一个对象

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

　　　　* A:在类中的位置不同
　　　　* 成员变量：在类中方法外
　　　　* 局部变量：在方法定义中或者方法声明上
　　　　* B:在内存中的位置不同
　　　　* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
　　　　* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
　　　　* C:生命周期不同
　　　　* 成员变量：随着对象的创建而存在，随着对象的消失而消失
　　　　* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
　　　　* D:初始化值不同
　　　　* 成员变量：有默认初始化值
　　　　* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

　　　　* 注意事项：
　　　　* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

匿名对象的概述和应用:　　　　　　　　　　　

　　　　* A:什么是匿名对象
　　　　* B:匿名对象应用场景
　　　　* a:调用方法，仅仅只调用一次的时候。
　　　　* 那么，这种匿名调用有什么好处吗?
　　　　* 节省代码
　　　　* 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
　　　　* b:匿名对象可以作为实际参数传递

private关键字的概述和特点：　

　private关键字特点
　　* a:是一个权限修饰符
　　* b:可以修饰成员变量和成员方法
　　* c:被其修饰的成员只能在本类中被访问

构造方法的重载及注意事项:

　　　　* B:构造方法注意事项
　　　　* a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
　　　　* b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
　　　　* 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
　　　　* C:给成员变量赋值的两种方式
　　　　* a:setXxx()方法
　　　　* b:构造方法

static关键字的特点：

　　　　* A:static关键字的特点
　　　　* a:随着类的加载而加载
　　　　* b:优先于对象存在
　　　　* c:被类的所有对象共享
　　　　* 举例：咱们班级的学生应该共用同一个班级编号。
　　　　* 其实这个特点也是在告诉我们什么时候使用静态?
　　　　* 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
　　　　* 举例：
　　　　* 饮水机(用静态修饰)
　　　　* 水杯(不能用静态修饰)
　　　　* d:可以通过类名调用
　　　　* 其实它本身也可以通过对象名调用。
　　　　* 推荐使用类名调用。
　　　　* 静态修饰的内容一般我们称其为：与类相关的，类成员

static的注意事项:

　　　* A:static的注意事项
　　　　* a:在静态方法中是没有this关键字的
　　　　* 如何理解呢?
　　　　* 静态是随着类的加载而加载，this是随着对象的创建而存在。
　　　　* 静态比对象先存在。
　　　　* b:静态方法只能访问静态的成员变量和静态的成员方法
　　　　* 静态方法：
　　　　* 成员变量：只能访问静态变量
　　　　* 成员方法：只能访问静态成员方法
　　　　* 非静态方法：
　　　　* 成员变量：可以是静态的，也可以是非静态的
　　　　* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
　　　　* 简单记：
　　　　* 静态只能访问静态。

静态变量和成员变量的区别:　　　

　　　　* 静态变量也叫类变量 成员变量也叫对象变量
　　　　* A:所属不同
　　　　* 静态变量属于类，所以也称为为类变量
　　　　* 成员变量属于对象，所以也称为实例变量(对象变量)
　　　　* B:内存中位置不同
　　　　* 静态变量存储于方法区的静态区
　　　　* 成员变量存储于堆内存
　　　　* C:内存出现时间不同
　　　　* 静态变量随着类的加载而加载，随着类的消失而消失
　　　　* 成员变量随着对象的创建而存在，随着对象的消失而消失
　　　　* D:调用不同
　　　　* 静态变量可以通过类名调用，也可以通过对象调用
　　　　* 成员变量只能通过对象名调用

多态中向上转型和向下转型:

　　　　* 父类是Animal,子类是Cat
　　　　* Animal a = new Cat();向上转型
　　　　* Cat c = new Animal();错误的
　　　　* Cat c = (Cat)a;向下转型

抽象类的概述及其特点：

　　　　* B:抽象类特点
　　　　* a:抽象类和抽象方法必须用abstract关键字修饰
　　　　* abstract class 类名 {}
　　　　* public abstract void eat();
　　　　* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
　　　　* c:抽象类不能实例化那么，抽象类如何实例化呢?
　　　　* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
　　　　* d:抽象类的子类
　　　　* 要么是抽象类
　　　　* 要么重写抽象类中的所有抽象方法

抽象类的成员特点:　

　　* A:抽象类的成员特点
　　　　* a:成员变量：既可以是变量，也可以是常量。
　　　　* b:构造方法：有。
　　　　* 用于子类访问父类数据的初始化。
　　　　* c:成员方法：既可以是抽象的，也可以是非抽象的。

　　B:抽象类的成员方法特性：
　　　　* a:抽象方法 强制要求子类做的事情。
　　　　* b:非抽象方法 子类继承的事情，提高代码复用性。

接口的概述及其特点：

　　* A:接口概述
　　　　* 从狭义的角度讲就是指java中的interface
　　　　* 从广义的角度讲对外提供规则的都是接口
　　* B:接口特点
　　　　* a:接口用关键字interface表示
　　　　* interface 接口名 {}
　　　　* b:类实现接口用implements表示
　　　　* class 类名 implements 接口名 {}
　　　　* c:接口不能实例化
　　　　* 那么，接口如何实例化呢?
　　　　* 按照多态的方式来实例化。
　　　　* d:接口的子类
　　　　* a:可以是抽象类。但是意义不大。
　　　　* b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

接口的成员特点:

　　* A:接口成员特点
　　　　* 成员变量；只能是常量，并且是静态的。
　　　　* 默认修饰符：public static final
　　　　* 建议：自己手动给出。
　　　　* 构造方法：接口没有构造方法。
　　　　* 成员方法：只能是抽象方法。
　　　　* 默认修饰符：public abstract
　　　　* 建议：自己手动给出。

类与类,类与接口,接口与接口的关系：

　　　　* A:类与类,类与接口,接口与接口的关系
　　　　* a:类与类：
　　　　* 继承关系,只能单继承,可以多层继承。
　　　　* b:类与接口：
　　　　* 实现关系,可以单实现,也可以多实现。
　　　　* 并且还可以在继承一个类的同时实现多个接口。
　　　　* c:接口与接口：
　　　　* 继承关系,可以单继承,也可以多继承

抽象类和接口的区别:

　　* A:成员区别
　　　　* 抽象类：
　　　　* 成员变量：可以变量，也可以常量
　　　　* 构造方法：有
　　　　* 成员方法：可以抽象，也可以非抽象
　　　　* 接口：
　　　　* 成员变量：只可以常量
　　　　* 成员方法：只可以抽象

　　* B:关系区别
　　　　* 类与类
　　　　* 继承，单继承
　　　　* 类与接口
　　　　* 实现，单实现，多实现
　　　　* 接口与接口
　　　　* 继承，单继承，多继承

　　* C:设计理念区别
　　　　* 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
　　　　* 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。