你对面向对象的理解：封装、继承、多肽；
1.什么是类？什么是对象？
1)现实世界是由很多很多对象组成的
基于对象抽出了类
2)对象:真实存在的单个的个体
类:类型/类别，代表一类个体
3)类中可以包含:
3.1)所有对象所共有的属性/特征------------成员变量
3.2)所有对象所共有的行为-----------------方法
4)一个类可以创建多个对象，
同一类型所创建的对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例
2.方法的签名:方法名+参数列表
3.方法的重载(Overload):
1)发生在同一个类中，方法名称相同，参数列表不同编译器在编译时会根据方法的签名自动绑定调用的方法
|
构造方法只能在构造方法里面调用 |
|
构造方法的定义：方法名称与类同名；无返回值类型 |
1)给成员变量赋初值
2)与类同名，没有返回值类型
3)在创建对象时被自动调用
4)若自己不写构造方法，则编译器默认一个无参构造方法，
若自己写了构造方法，则不再默认提供
5)构造方法可以重载
5.this:指代当前对象，哪个对象调用方法它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法:
1) this.成员变量名--------------访
2) 问成员变量
2)this.方法名()----------------调用方法(一般不用)
3)this()-----------------------调用构造方法
6.null:空，没有指向任何对象
若引用的值为null，则该引用不能再进行任何操作了
若操作则发生NullPointerException空指针异常
7.引用类型之间画等号:
1)指向同一个对象
2)通过一个引用对数据的修改会影响另一个引用对数据的访问
eg:房子钥匙
基本类型之间画等号:
1)赋值
2)对一个变量的修改不会影响另一个变量
eg:身份证复印件
图1：null和NullPointerException
图2：堆和栈内存图
图3：基本类型与引用类型之间画等号
8.默认值
byte,short,int,long,char-----------------0
float,double--------------------------------0.0
boolean-------------------------------------false
引用类型---------------------null
基本数据类型-----------------只能装一个数据
数组类型---------------------必须相同数据类型
自己造个数据类型-------------想装什么就装什么
9.引用类型数组:
|
动态初始化 |
stus[0] = new Student("zhangsan",25,"LF");
stus[1] = new Student("lisi",26,"JMS");
stus[2] = new Student("wangwu",24,"SD");
2)Student[] stus = new Student[]{
|
静态方式初始化对象数组 |
new Student("lisi",26,"JMS"),
new Student("wangwu",24,"SD")
};
3)int[][] arr = new int[3][];------------数组的数组
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[1][0] = 100;
4)int[][] arr = new int[3][4]; //3行4列
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j] = 100;
}
}
10.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类/父类:所有派生类所共有的属性和行为
派生类/子类:派生类所特有的属性和行为
4)派生类继承超类后，派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类----------单一继承
6)继承具有传递性的
7)java规定:在构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法
------则默认super()调用超类的无参构造方法
在派生类的构造方法中若自己调用了超类的构造方法
------则不再默认提供
super()调用超类构造方法必须位于派生类构造方法的第一行
11.super:指代当前对象的超类对象
super的用法:
1)super.成员变量名-------------访问超类的成员变量
2)super.方法名()---------------调用超类的方法---------明天讲
3)super()----------------------调用超类的构造方法
说明:
1.继承要符合is a(是一个)的关系
2.问:派生类可以继承超类的构造方法吗?
答:不可以，超类构造是由派生类来调用的
图1：基本类型数组
图2：引用类型数组
|
对象的比较：有两种方式可用于对象间的比较，即“==”运算符与equans()方法。“==”运算符用于比较两个对象的内存地址是否相等，equans()方法用于比较两个对象的内容是否一致。 |
12.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么，看引用的类型
13.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
3)重写遵循"两同两小一大"原则:---------了解
|
静态方法不能直接调用非静态方法，非静态方法可以调用静态方法 |
3.1.1)方法名称相同
3.1.2)参数列表相同
3.2)两小:
3.2.1)派生类方法的返回值类型小于或等于超类方法的
1)void时，必须相等
2)基本数据类型时，必须相等
3)引用数据类型时，小于或等于
3.2.2)派生类方法抛出的异常小于或等于超类方法的-------异常之后讲
3.3)一大:
3.3.1)派生类方法的访问权限大于或等于超类方法的-------明天讲
14.重写与重载的区别:---------------常见面试题
1)重写(Override):
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)遵循"运行期"绑定，看对象的类型来调用方法
2)重载(Overload):
2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
2.2)遵循"编译期"绑定，看参数/引用的类型来绑定方法
15.package:
1)避免类名的冲突
2)包名可以有层次结构，同包中的类不能同名
3)类的全称为: 包名.类名
4)建议:包名所有字母都小写
import:
1)同包中的类可以直接访问，
不同包中的类不可以直接访问，想访问只有如下两种方式:
1.1)先import声明类再访问类----建议
1.2)类的全称------------------太繁琐
16.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上四种都可以
17.final:最终的、不可改变的----------应用率极低
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
18.static:静态的
1)静态变量:
1.1)由static修饰的
1.2)属于类的，存储在方法区中，只有一份
1.3)常常通过类名点来访问
1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
2.1)由static修饰的
|
非静态方法可以访问类中的任何成员，静态方法只能访问类中的静态成员 |
2.3)常常通过类名点来访问
2.4)静态方法没有隐式this传递的，
静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)由static修饰的
3.2)在类被加载期间自动执行，因类只被加载一次，
所以静态块也只执行一次
3.3)何时用:初始化/加载静态资源(图片、音频、视频等)
19.成员变量分两种:
1)实例变量:没有static修饰，属于对象的，存储在堆中，
有几个对象就有几份
通过对象名点来访问
2)静态变量:由static修饰的，属于类的，存储在方法区中，
只有一份
通过类名点来访问
20.staticfinal常量:
1)必须声明同时初始化
2)常常通过类名点来访问、不能被改变
3)建议:常量名所有字母都大写，多个单词之间用_分隔
4)编译器在编译时会将常量直接替换为具体的值，效率高
5)何时用:数据永远不变，并且经常使用
21.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有具体的实现(连{}都没有)
22.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类-------我乐意
3)抽象类不能被实例化
4)抽象类是需要被继承的，派生类:
4.1)重写所有抽象方法------变不完整为完整
4.2)也声明为抽象类--------不常用
5)抽象类的意义:
5.1)封装派生类所共有的属性和行为--------代码复用
5.2)为所有派生类提供一种统一的类型------向上造型
5.3)可以包含抽象方法，为所有派生类提供统一的入口，
派生类的具体实现不同，但入口是一致的
23.成员内部类:应用率低
1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类
2)内部类只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
eg: 外部类名.this.
24.匿名内部类:
1)若想创建一个类(派生类)的对象，并且对象只被创建一个，
此时该类不必命名，称之为匿名内部类
2)jdk1.7(含)以前，匿名内部类中想访问外面的变量，
该变量必须是final的
面试题:
问:内部类有独立的.class吗?
答:有
步骤:
1.先写行为/方法:
1)若行为为某一个对象所特有的行为，则设计在特定的类中
2)若行为为所有对象所共有的行为，则设计在超类中
2.页面去调:
|
“实现接口”与“继承父类”不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。并且，具体类需要实现这些接口中定义的所有抽象方法； 接口间可以存在继承关系，一个接口可以通过extends关键字继承另外多个接口。子接口继承了父接口中定义的所有方法。 |
2)事件触发的，在侦听器中调用
25.接口:
1)是一种数据类型(引用类型)
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/派生类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，用逗号分隔
若又继承又实现时，必须先继承后实现
7)接口可以继承接口
设计规则:
1.将所有派生类所共有的属性和行为，抽到超类中----抽共性
2.派生类的行为都一样，设计为普通方法
派生类的行为不一样，设计为抽象方法
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)
26.多态:
1)多态的意义:
1.1)同一类型的引用指向不同的对象时，有不同的实现
----行为的多态:cut(),step(),getImage()...
1.2)同一个对象被造型为不的类型时，有不同的功能
----对象的多态:我，你，水同，被撞的敌人...
2)向上造型/自动类型转换:
2.1)超类型的引用指向派生类的对象
2.2)能造型成为的类型有: 超类+所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有如下两种:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现该接口或继承的该类
4)强转时若不符合如上两个条件，则发生ClassCastException类型转换异常，
建议:强转之前先通过instanceof来判断引用的对象是否是该类型
27.内存管理:由JVM来管理
1)堆:
1.1)存储new出来的对象(包括实例变量)
1.2)垃圾:没有任何引用所指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾，
回收过程是透明的(看不到的)，
不一定一发现垃圾就立刻回收，
调用System.gc()建议虚拟机尽快调度GC来回收垃圾
1.3)实例变量的生命周期:
创建对象时存储堆中，对象被回收时一并被回收
1.4)内存泄漏:不再使用的对象还没有被及时的回收
建议:不再使用的对象及时将引用设置为null
2)栈:
2.1)存储正在调用的方法中的所有局部变量(包括方法的参数)
2.2)调用方法时在栈中为该方法分配一块对应的栈帧，
栈帧中包含局部变量(包括方法的参数),
方法调用结束时，栈帧被清除，局部变量一并被清除
2.3)局部变量的生命周期:
调用方法时存储在栈中，方法结束栈帧被清除，局部变量一并失效
3)方法区:
3.1)存储.class字节码文件(包括方法、静态变量)
3.2)方法只有一份，通过this来区分具体的调用对象
面向对象三大特征:
1.封装:
1)类:封装的是对象的属性和行为
2)方法:封装的是一段特定的业务逻辑功能
3)访问控制修饰符:封装的是具体访问的权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的行为
派生类:派生类所特有的属性和行为
3)传递性，单一继承、多接口实现
3.多态:
1)意义:行为的多态(所有抽象方法都是多态的)
对象的多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof判断
3)多态的表现形式:
3.1)重写:根据对象的不同来实现多态
3.2)重载:根据参数的不同来实现多态
扫一扫
2379
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
