2.面向对象（OOP）总结

1.什么是类？什么是对象？
1)现实世界是由很多很多对象组成的
基于对象抽出了类
2)对象:真实存在的单个的个体
类:类型/类别，代表一类个体
3)类中可以包含:
3.1)对象所共有的属性/特征-------------成员变量
3.2)对象所共有的行为------------------方法
4)一个类可以创建多个对象
同一类型所创建的对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例
2.如何创建类？如何创建对象？如何访问成员？

射击游戏需求:
1)所参与的角色:
英雄机、子弹、小敌机、大敌机、小蜜蜂、天空
2)对象间的关系:
2.1)英雄机可以发射子弹(单倍火力(0)、双倍火力(>0))
2.2)子弹可以射击敌人(小敌机、大敌机、小蜜蜂)
2.2.1)打掉小敌机，玩家得1分
2.2.2)打掉大敌机，玩家得3分
2.2.3)打掉小蜜蜂，英雄机得奖励(1条命、40火力值)
发射一次双倍火力，则火力值减2
2.3)英雄机、子弹、小敌机、大敌机、小蜜蜂都在天空上飞
2.4)敌人撞到英雄机，则英雄机减1条命，同时清空火力值
英雄机命数为0时，则游戏结束

0.方法的签名: 方法名+参数列表
1.方法的重载(overload):
1)发生在同一个类中，方法名相同，参数列表不同，方法体不同
2)编译器在编译时会根据方法的签名自动绑定调用的方法
2.构造方法:
1)给成员变量赋初值
2)与类同名，没有返回值类型
3)在创建(new)对象时被自动调用
4)若自己不写构造方法，则编译器默认一个无参的构造方法
若自己写了构造方法，则不再默认提供
5)构造方法可以重载
3.this:指代当前对象，哪个对象调用方法指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法:
1)this.成员变量名-------------访问成员变量
2)this.方法名()---------------调用方法(一般不用)
3)this()----------------------调用构造方法
4.null:空，没有指向任何对象
若引用的值为null，则该引用不能再进行任何操作了,
若操作则发生NullPointerException空指针异常
5.引用类型变量画等号:
1)指向同一个对象
2)通过一个引用对数据的修改会影响另一个引用对数据的访问
eg:房子钥匙
基本类型变量画等号:
1)赋值
2)对一个变量的修改不会影响另一个变量的访问
eg:身份证复印件

1.引用类型数组:
1)Student[] stus = new Student[3]; //创建Student数组对象
stus[0] = new Student(“zhangsan”,25,“LF”); //创建Student对象
stus[1] = new Student(“lisi”,26,“JMS”);
stus[2] = new Student(“wangwu”,27,“SD”);
System.out.println(stus[0].name); //输出第1个学生的名字
stus[1].age = 22; //给第2个学生的年龄赋值为22
stus[2].sayHi(); //第3个学生和大家问好
2)Student[] stus = new Student[]{
new Student(“zhangsan”,25,“LF”),
new Student(“lisi”,26,“JMS”),
new Student(“wangwu”,27,“SD”)
};
2.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类:所有派生类所共有的属性和行为
派生类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有:超类的+派生类的
5)一个超类可以具有多个派生类
一个派生类只能有一个超类---------单一继承
6)具有传递性
7)java规定:构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法
------则默认super()调用超类的无参构造方法
在派生类的构造方法中若调用了超类的构造方法
------则不再默认提供super()
super()调用超类构造方法必须位于派生类构造方法的第一行
3.super:指代当前对象的超类对象
super的用法:
1)super.成员变量名------------访问超类的成员变量
2)super.方法名()--------------调用超类的方法---------明天下午讲
3)super()---------------------调用超类的构造方法

1.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
2.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)重写要遵循"两同两小一大"原则:------了解
3.1)两同:
3.1.1)方法名称相同
3.1.2)参数列表相同
3.2)两小:
3.2.1)派生类方法的返回值类型小于或等于超类方法的
1)void时，必须相等
2)基本数据类型时，必须相等
3)引用数据类型时，小于或等于
3.2.2)派生类方法抛出的异常小于或等于超类方法的--------异常之后讲
3.3)一大:
3.3.1)派生类方法的访问权限大于或等于超类的方法的------明天讲
3.重写与重载的区别:------------常见的面试题
1)重写(Override):
1.1)发生在父子类中，方法名相同，参数列表相同，方法体不同
1.2)遵循"运行期绑定"，根据对象的类型来调用方法
2)重载(Overload):
2.1)发生在一个类中，方法名相同，参数列表不同，方法体不同
2.2)遵循"编译期绑定"，根据参数/引用的类型来绑定方法

1.package:
1)作用:避免类名的冲突
2)类的全称:包名.类名
3)建议:包名所有字母都小写
4)同包中的类不能同名
import:
1)同包中的类可以直接访问，
不同包中的类不能直接访问，想访问如下两种方式:
1.1)先import声明类再访问类-----建议
1.2)类的全称---------太繁琐，不建议
2.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、派生类、同包类
4)默认的:什么也不写，本类、同包类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上四种都可以
3.final:最终的、不可改变的--------单独应用几率极低
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
4.static:静态的
1)静态变量:
1.1)由static修饰
1.2)属于类，存储在方法区中，只有一份
1.3)常常通过类名点来访问
1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
2.1)由static修饰
2.2)属于类，存储在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法中没有隐式的this传递，
静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)属于类的，在类被加载期间自动执行，
因为类只被加载一次，所以静态块只执行一次
3.2)何时用:加载/初始化静态资源(图片、音频、视频等)

1.static final常量:应用率高
1)必须声明同时初始化
2)类名点来访问，不能被改变
3)建议:常量名所有字母都大写，多个单词之间用_分隔
4)编译器在编译时将常量直接替换为具体的值，效率高
5)何时用:数据永远不变、并且经常使用
2.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有具体的实现(连{}都没有)
3.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类------我乐意
3)抽象类不能被实例化
4)抽象类是需要被继承的，派生类:
4.1)重写所有抽象方法------变不完整为完整
4.2)也声明为抽象类--------不常用
5)抽象类的意义:
5.1)封装派生类所共有的属性和行为--------代码复用
5.2)为所有派生类提供统一的类型----------向上造型
5.3)可以包含抽象方法，为所有派生类提供统一的入口，
派生类的具体实现不同，但入口是一致的

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-----抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法

2进制

什么2进制

逢2进1的计数规则

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
00000000 00000000 00000000 00000011
00000000 00000000 00000000 00000100
00000000 00000000 00000000 00000101
00000000 00000000 00000000 00000110
00000000 00000000 00000000 00000111
00000000 00000000 00000000 00001000
00000000 00000000 00000000 00001001
00000000 00000000 00000000 00001010
00000000 00000000 00000000 00001011
00000000 00000000 00000000 00001100
00000000 00000000 00000000 00001101

计算机为什么使用2进制

电器设备设计成处理2进制，其成本最优。

计算机如何解决人类和计算机直接的机制矛盾

16进制

16进制用于缩写（简写）2进制，将2进制从后向前每4位数转换为1位16进制。

补码

补码： 将固定位数的2进制数分一半作为负数使用的编码规则。其目的是为了解决负数计算问题。

以4位补码为例研究补码的编码规则! 将4位2进制分一半作为负数使用。

经典面试题目：

System.out.println(~100+1);
如上代码的输出结果：
A. -99 B.-100 C.-101 D.-102
答案：B

100    00000000 00000000 00000000 01100100
~100   11111111 11111111 11111111 10011011  -101
~100+1 11111111 11111111 11111111 10011100  -100

System.out.println(~100);
如上代码的输出结果：
A. -99 B.-100 C.-101 D.-102
答案：C

2进制运算

与 &  或|  取反~  左移位<< 右移位>>> 数学右移位>> 

与计算 & （逻辑乘法）

计算规则:

0 & 0 -> 0
0 & 1 -> 0
1 & 0 -> 0
1 & 1 -> 1

有0则0

计算时候，将两个数对其位数，将齐的数字进行 “&” 计算

举个栗子：

n=     01110100 01111101 00101111 01101011
m=     00000000 00000000 00000000 11111111
k=n&m  00000000 00000000 00000000 01101011

如上计算的意义：k是n的最后8位数！也就将n的最后8位切下放到k中。
称为掩码(mask)计算，其中m称为掩码（mask），m有8个1时候称为8位掩码

代码：

int n = 0x747d2f6b;
int m = 0xff;// 0xf  0x3f  0xffff
int k = n&m;
//按照2进制输出 n m k 的值

右移位计算 >>>

规则： 将数字整体向右移位，高位补，低位自动溢出

举个栗子：

n=        01101001 11111010 01110000 01010101
m=n>>>1   001101001 11111010 01110000 0101010
k=n>>>2   0001101001 11111010 01110000 010101
g=n>>>8   00000000 01101001 11111010 01110000 

代码：

int n = 0x69fa7055;
int m = n>>>1;
int k = n>>>2;
int g = n>>>8;
//将整数n拆分为4个字节 b1 b2 b3 b4
int b1 = (n>>>24) & 0xff;
int b2 = (n>>>16) & 0xff;
int b3 = (n>>>8) & 0xff;
int b4 = n & 0xff;

或计算 | （逻辑加法）

基本规则：

0 | 0 -> 0
0 | 1 -> 1
1 | 0 -> 1
1 | 1 -> 1

有1则1

将两个数对齐位置，对应数字进行 或计算

举个栗子：

n = 	 00000000 00000000 11001101 00000000  n=0xcd00
m =      00000000 00000000 00000000 11011111  m=0xdf;
k =n|m   00000000 00000000 11001101 11011111  k=n|m

b1=      00000000 00000000 00000000 11011101  b1=0xdd;
b2=      00000000 00000000 00000000 01101110  b2=0x6e;
b3=      00000000 00000000 00000000 10111011  b3=0xbb;
b4=      00000000 00000000 00000000 10101101  b4=0xad;

b1<<24   11011101 00000000 00000000 00000000  
b2<<16   00000000 01101110 00000000 00000000 		
b3<<8    00000000 00000000 10111011 00000000 
b4=      00000000 00000000 00000000 10101101

x=       11011101 01101110 10111011 10101101
            b1      b2        b3       b4

x= (b1<<24)|(b2<<16)|(b3<<8)|b4

移位计算的数学意义

复习： 移动小数点计算

如：                  52439.
小数点向右移动一次：  524390.  数字扩大10倍
小数点向右移动二次： 5243900.  数字扩大100倍
假如小数点不动，数字向左移动：数字向左移动一次，数字扩大10倍

2进制时候： 数字向左移动：数字向左移动一次，数字扩大2倍

128 64 32  16   8   4   2   1
 0  0   1   1   0   0   1   0
 0  1   1   0   0   1   0   0

验证：

int n = 50;
int m = n<<1; // n*2
int k = n<<2; // n*4
int g = n<<3; // n*8

经典面试题目：

如何快速计算 n * 8 
答案：（ n<<3 ）

逻辑右移位 >>> 数学右移位 >> 的区别

数学右移位 >> 计算的结果是: 数据除以2向小取整数的结果

区别：

逻辑右移位 >>> 移位时候，正数高位补0 负数高位补0
数学右移位 >> 移位时候，正数高位补0 负数高位补1

举个栗子:

n=      11111111 11111111 11111111 11001110   -50    
m=n>>1  111111111 11111111 11111111 1100111   -25 
k=n>>2  1111111111 11111111 11111111 110011   -13 

x=n>>>1 011111111 11111111 11111111 1100111    
y=n>>>2 0011111111 11111111 11111111 110011     

逻辑右移位 >>> 单纯将数字向右移动，用于数字的拆分计算
数学右移位 >> 用于替代特殊除法计算

1.成员内部类:单独应用几率不高
1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
eg: 外部类名.this.
2.匿名内部类:
1)若想创建一个类(派生类)的对象，并且对象只被创建一次，
此时该类不必命名，称为匿名内部类
2)匿名内部类中若想访问外部的变量，该变量必须是final的
(在JDK1.8之前有此要求，JDK1.8可以不加final了)

常见面试题:
问:内部类有独立的.class吗?
答:有

做功能的步骤:
1.先写行为:
1)若为对象所特有的行为，就将方法设计在对应的类中
2)若为所有对象所共有的行为，就将方法设计在超类中
2.窗口调用:
1)定时触发的，在定时器中调用
2)事件触发的，在侦听器中调用

程序的运行结果与你所预期的结果不同，怎么办?
1)打桩: System.out.println(数据);
2)Debug调试:

1.接口:
1)是一种数据类型(引用类型)
2)由interface定义
3)只能包含常量和抽象方法
4)不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，应先继承后实现
7)接口可以继承接口

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-------抽共性
2)所有派生类的行为都一样，设计为普通方法
所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
符合既是也是原则时，使用接口
接口是对继承的单根性的扩展---------多继承

1.多态:
1)意义:
1.1)同一类型的引用，在指向不同的对象时，有不同的实现
----行为的多态:cut()、run()、step()、getImage()…
1.2)同一个对象，被造型为不同的类型时，有不同的功能
----对象的多态:我、水…
2)向上造型/自动类型转换:
2.1)超类型的引用指向派生类的对象
2.2)能造型成为的类型有: 超类+所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有如下两种:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，继承了该类或实现了该接口
4)强转时若不符合如上条件，则发生ClassCastException类型转换异常
建议:在强转之前先通过instanceof判断引用指向的对象是否是该类型

1.内存管理:由JVM管理
1)堆:
1.1)存储new出来的对象(包括实例变量)
1.2)垃圾:没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾，
回收过程是透明的(看不到的)，
不一定一发现垃圾就立刻回收,
调用System.gc()可以建议虚拟机尽快调度GC来回收
1.3)内存泄漏:不再使用的内存还没有被及时的回收
建议:当对象不再使用时及时将引用设置为null
1.4)实例变量的生命周期:
创建对象时存储在堆中，对象被回收时一并被回收
2)栈:
2.1)存储正在调用的方法中的所有局部变量(包括方法参数)
2.2)调用方法时会在栈中为该方法分配对应的栈帧，
栈帧中存储方法中的局部变量(包括方法的参数),
方法调用结束时，栈帧被清除，局部变量一并失效
2.3)局部变量的生命周期:
方法被调用时存储在栈中，方法结束时与栈帧一并被清除
3)方法区:
3.1)存储.class字节码文件(包括静态变量、方法)
3.2)方法只有一份，通过this来区分具体的调用对象

面向对象三大特征:--------------常见面试题
1.封装:
1)类:封装的是对象的属性和行为
2)方法:封装的是特定的业务逻辑功能实现
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的行为
派生类:派生类所特有的属性和行为
3)单一继承、多接口实现，传递性
3.多态:
1)意义:
1.1)行为的多态(所有抽象方法都是多态的)
1.2)对象的多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof判断
3)多态的表现形式:
3.1)重写:根据对象的不同来表现多态
3.2)重载:根据参数的不同来表现多态

面向对象课程安排:
第一天:
理论:
1.什么是类？什么是对象？
2.如何创建类？如何创建对象？如何访问成员？
项目:
3.创建了6个对象类，创建World类并测试
第二天:
理论:
1.方法的重载
2.构造方法
3.this
5.null和NullPointerException
6.引用类型变量画等号
项目:
4.给6个对象类添加构造方法，并测试
第三天:
理论:
1.引用类型数组
3.继承
5.super
项目:
2.设计小敌机、大敌机、小蜜蜂、子弹数组，并测试
4.设计FlyingObject超类，6个对象类继承FlyingObject
6.在FlyingObject中设计两个构造方法，6个对象类分别调用
第四天:
理论:
1.向上造型
3.方法的重写、重写与重载的区别
项目:
2.将小敌机、大敌机、小蜜蜂数组合为FlyingObject数组，并测试
4.在6个对象类中重写超类的step()
5.画窗口
第五天:
理论:
1.package和import
2.访问控制修饰符
4.final
5.static
项目:
3.给类中成员添加访问修饰符
6.设计Images图片的工具类，给对象准备图片
第六天:
理论:
1.static final常量
3.抽象方法
4.抽象类
项目:
2.将窗口的宽和高设计为常量，适当地方做修改
5.画对象
第七天:
理论:
1.成员内部类
2.匿名内部类
项目:
3.敌人入场
4.子弹入场
5.飞行物移动
第八天:
理论:
3.接口
项目:
1.英雄机随着鼠标移动
2.删除越界的敌人和子弹
第九天:
理论:
1.多态
项目:
2.子弹与敌人的碰撞
3.画分和画命
第十天:
理论:
1.内存管理
项目:
2.英雄机与敌人的碰撞
3.检测游戏结束
4.画状态

1.冒泡排序算法:
1)5个数冒4轮
2)每一轮都是从第1个元素开始冒
每一次都是和它的下一个元素比
3)冒出来的就不带它玩了
2.根据图形的周长，求一组图形的最大面积
1)圆形: 面积=0.0796周长周长
2)方形: 面积=0.0625周长周长
3)六边形: 面积=0.0721周长周长
3.当程序的运行结果与你所预期的结果不同时:
1)打桩: System.out.println(数据);
2)Debug调试工具:—添加断点
2.1)掌握四个键:
2.1.1)F5:单步调试(会进入到方法中)
2.1.2)F6:逐过程调试(不会进入到方法中)
2.1.3)F7:结束方法的调试
2.1.4)F8:直接跳到下一个断点(若后面无断点则结束调试)
2.2)会看两个东西:
2.2.1)会看变量
2.2.2)会添加监视(看表达式–选中表达式，右键Watch)