JavaOOP面向对象笔记

Java OOP
class cell{int x=1;}
类名属性类体

类内的变量（成员、属性）

cell c1 = new cell();
引用变量创建对象
内存：方法区；本地方法区；栈；堆。
局部变量（方法中）：在栈中分配
实例变量（类中声明）：随着对象创建在堆中分配；
对象都在堆中分配
对象的方法
业务层面：方法是对的行为，是对象的功能/动作
数据层面：方法是算法，是操作数据模型的计算过程；

this
（运行/调用期间）调用方法对象自身，是将调用方法对象引用隐含传递给this变量
Super
访问父类中的属性
空指针异常（NullPointerException）
在调用方法（访问属性）之前将变量引用到对象
---------------------------------------------------------------------------------------------
构造器
1)构造器（构造方法）在类里；
2)构造器名与类名相同；
3)构造方法不能声明返回值类型；

继承中的构造器
1)构造器不能继承；
2)子类构造器中一定调用父类构造器
子类构造器中默认调用父类无参构造器
可以使用super（）调用父类构造器

业务层面：构造器是用来创建对象的，使用new来调用，

Java类一定有构造器，没有声明构造器，编译器会自动生成无参的默认构造器，声明后不再添加。

重载(Overload)
在同一个类中，允许同时存在一个以上的同名函数，只要他们的参数列表不同即可。
参数列表不同，可以是参数的类型或个数不同，也可以是不同类型参数的顺序不同。
1、相同方法名，不同参数表。
2、方法重载时，对于参数的匹配有个向上就近原则。(这样可以节省栈空间资源)；
3、为什么面向对象中要有方法重载？
方法的重载使同一类方法由于参数造成的差异对于对象的使用者是透明的。
对象的使用者只负责把参数交给对象，而具体怎么实现由对象内部决定。
4、Java中的运算符重载
java中唯一重载的运算符是String类型的“+”号，任何类型+String类型结果都为Stirng类型。
5、注意点：重载不仅出现在同一个类中，也可以出现在父子类中。
重载的方法只是刚好有相同名字的不同方法

方法的覆盖 (Override) 重写
继承之后，想改变由父类继承下来的方法。
1. 同样的方法名、参数列表、返回类型(从Java 5 起，返回类型可以是子类型)
2. 访问权限不能更小
3. 异常不能更宽 (可以抛出更少或是更窄的检查异常，或者任何非检查异常)
私有方法不能被继承、重写！
重写的前提是继承！
重构 (extract Method)
消除代码的重复，提高代码的可维护性。整理凌乱的代码，把可重用的代码块包装起来。

常用重复的方法封装成工具类(工具类太多则做成工具箱)，一般都是静态方法和常量，没有属性。
在eclipse里，选中要重构的代码，右键Refactor-Extract Mathod 或(Shift+Alt+M)
创建对象的步骤
1、分配空间
2、初始化属性
3、调用构造方法
注：构造方法不能手工调用，在对象的生命周期内构造方法只调用一次。
属性静态绑定；属性的访问绑定到变量类型的，根据变量属性访问相应的属性；方法的访问根据对象类型。
面向对象的三大特性：
封装(Encapsulation)、继承(Inheritance)、多态polymiorphism

封装：
1．定义：指一个对象的内部状态对外界是透明的，对象与对象之间只关心对方有什么方法，而不关心属性。
封装使实现的改变对架构的影响最小化。封装后的代码更具有安全性、可扩展性和可维护性。
2．原则：封装使对象的属性尽可能的私有，根据需要配上相应的get/set方法，对象的方法尽可能的公开。
该隐藏的一定要隐藏，该公开的一定要公开。
3．方法公开的是声明而不是实现。使方法实现的改变对架构的影响最小化。
4．访问权限控制从严到宽
private :仅本类成员可见；尽可能使用私有的
default :本类＋同包类可见(默认)；少使用默认的
protected:本类＋同包＋不同包的子类；只给子类使用
public :公开
注：这里的同包指的是跟父类所在的包相同。一个文件一个共有类。
5、完全封装：属性全部私有，并提供相应的get/set方法。
优点：
1．事物的内部实现细节隐藏起来
2．对外提供一致的公共的接口――间接访问隐藏数据
3．可维护性
一、继承：
1 定义：基于一个已存在的类构造一个新类。
继承已存在的类就是复用这些类的方法和属性，在此基础上，还可以在新类中添加一些新的方法和属性。
2 父类到子类是从一般到特殊的关系。
3 继承用关键字extends
dog extends Animal :表示狗类继承了动物类
4 Java中只允许单继承(java简单性的体现)
父子类之间的关系是树状关系。(而多继承是网状关系)
5 父类中的私有属性可以继承但是不能访问。
也可以说父类中的私有属性子类不能继承。
6 原则：父类放共性，子类放个性。
7 构造方法不能被子类继承。
父类的成员能否继承到子类？
private：本类内部可以访问不能继承到子类
(default)：本类内部可以访问，同包其他类也可以访问
能否继承到子类？不一定：同包的可继承，不同包则不可继承。
protected：本类内部可以访问，不同包的子类也可以访问，同包其他类

也可以访问
能继承到子类
public：任何地方都可以访问能继承到子类
子类使用super 访问父类属性和方法；

继承的意义：
1. 避免了重复的程序代码，提高了程序的可重用性
2. 定义出共同的协议
二、带继承关系的对象创建的过程
1．递归的构造父类对象
2．分配空间
3．初始化属性
4．调用本类的构造方法
三、super 关键字
1．super()表示调用父类的构造方法
2．super()也和this一样必须放在构造方法的第一行第一句。不是构造方法则不用第一行。
3．super.表示调用父类的方法或属性。例：super.m();
4．super 可以屏蔽子类属性和父类属性重名时带来的冲突
5．在子类的构造函数中如果没有指定调用父类的哪一个构造方法，就会调用父类的无参构造方法，即super()
指向父类的引用
super.age
super.addAge()
调用父类的构造方法
super();
super(“wangcai”,8);
一个对象的创建过程
1. 当构造一个对象的时候，系统先构造父类对象，再构造子类对象。
2. 构造一个对象的顺序：(注意：构造父类对象的时候也是这几步)
递归地创建父类的 static 成员(即使只调用其子类静态成员，也会先创建父类静态成员)；
顺序地创建本类的 static 成员(只要调用这个类的属性或方法都需创建一次)；
递归地创建父类对象(先创建父类非静态成员，再调用父类构造方法)；
顺序地创建本类非静态成员(包括属性和方法)；
调用本类的构造方法(它可调用本类或父类的成员，也可调用本类的其他构造方法)。
创建完成了(更多详情参看下面：类加载的顺序)

四、白箱复用和黑箱复用
1．白箱复用：又叫继承复用，子类会继承父类所有的东西，
从某种程度上说白箱复用破坏了封装。是一种 is a 的关系。
例：class Liucy{
public void teachCpp(){System.out.println("Teach Cpp");}
public void chimogu(){ }
}
class Huxy extends Liucy{}
2、黑箱复用：又叫组合复用，是一种 has a 的关系。
例：class Liucy{
public void teachCpp(){System.out.println("Teach Cpp");}
public void chimogu(){ }
}
class Huxy {
private Liucy liucy = new Liucy();
public void teachCpp(){liucy.teachCpp();}
}
原则：组合复用取代继承复用原则。
使我们可以有机会选择该复用的功能。
多态
1．定义：是指一个对象可以有多种形态，换句话说多态使我们可以把一个子类对象看作是一个父类对象类型
(例：father A = new child() )。
多态指的是编译时的类型变化，而运行时类型不变。
2

．多态分为两种：编译时多态和运行时多态。
编译时类型：定义时类型(主观概念)把它看作什么。
运行时类型：真实类型(客观概念) 实际上他是什么。
重载是编译时多态，覆盖是运行时多态。在方法重载的情况下，参数类型决定于编译时类型。
3．作用：在需要一类对象的共性时，可以很容易的抽取。并且可以屏蔽不同子类对象之间所不关心的差异。
多态方便写出更通用的代码，以适应需求的不断变化
4．多态常见的用法：
(1)、多态用在方法的参数上
(2)、多态用在方法的返回类型上
5．运行时多态的三原则：
(1)、对象不变(改变的是主观认识)
(2)、对于对象的调用只能限于编译时类型的方法。
(3)、在程序的运行时，动态类型判定。运行时调用运行时类型，即他调用覆盖后的方法。
注意：多态时，只有一般方法是动态调用的；而 static 方法和 final 方法依然是静态调用的；属性全是静态调用的。
如：father A = new child(); 则A的一般方法是child的方法；但A的属性是father的属性。
同样：child C = new child(); 则 (father)C 的一般方法还是child的方法，但属性是father的属性。
if(cat instanceof Animal){ ... } //如果cat属于Animal类型则执行
强制类型转换，在迫不得已的时候再用。因为很容易出错。
static
修饰成员变量的意义

被类内所有实例共享，静态属性相当于全局变量；
静态属性
静态属性使用类名访问；在类中访问静态属性可以省略类名。
静态方法
常用于与当前对象无关的工具方法（如Arrays（） Math。sqrt（） integer）
属于类的方法，使用类名调用，不隐含this
非静态方法（对象方法）
使用对象调用，当前对象隐含this

代码块
可以在类中声明，包含语句，在创建对象是执行；
静态代码块
用static 修饰；类加载时执行一次；用于类一起加载静态资源（照片，配置文件）；
final
修饰类
不可以被继承；可以阻止继承以后的修改。API中的final类：String，Integer， Math ，Long，Double。
实际工作中一般不允许使用Final类；
修饰方法（Method）
不可以被子类重写
final变量
只能初始化一次，不能再修改；

对象数组
数组的成员是对象（对象的引用）；数组也是对象；
二维数组是假的，是元素为数组的一维数组；
new ClassNema[length];
new ClassNema[]{元素};
{}

abstract抽象
作用：作为共享代码的基类
语法：抽象类可以定义变量，引用子类型实例
抽象类不能创建实例
抽象类只能作为父类被继承
具体类继承抽象类必须实现全部的抽象方法，实现抽象方法是一种方法的重写；实现了父

类型定义的抽象方法，抽象方法是父类性对子类型的方法约定；

接口interface
1)特殊的抽象类，使用interface 关键字声明
2)接口中只能定义抽象方法和常量
3)接口可以定义变量，引用实现类实例（子类型）
4)接口不能直接实例化
5)接口可以继承接口
6)具体类可以实现（implements）接口，可以实现多个接口
7)具体类实现接口就必须实现全部的抽象方法
8)java利用接口解决了多继承的现象

接口描述的纯抽象慨念，经常用于描述软件之间的协定

内部类（类内部定义的类）
1)在类的内部使用和声明，封装类的可见范围
2)内部类也是类，可以用于任何使用类的地方

匿名类内部类
1)是直接继承父类并同时实例为对象
2)语法简洁
3)可以直接继承接口/抽象类创建匿名内部类实例
4)一个方法中的局部内部匿名类若想引用该方法中的局部变量，那么该变量必须为final的。
Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
repaint();
}
}, 800, 800);

this.requestFocus();// 请求输入焦点(当前面板)
/** 键盘事件 */
this.addKeyListener(new KeyListener() {
// 监听按键事件,KeyListener有Swing定义的；
public void keyTyped(KeyEvent e) {
}
/** 释放 */
public void keyReleased(KeyEvent e) {
}
/** 按下 */
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
}
});