java面向对象编程知识点总结 1.docx
《java面向对象编程知识点总结 1.docx》由会员分享，可在线阅读，更多相关《java面向对象编程知识点总结 1.docx（20页珍藏版）》请在冰点文库上搜索。
java面向对象编程知识点总结1
java中实现方法重载的条件:
1、在同一类中
2、方法名称相同，参数不相同（类型、个数、顺序）
3、与访问修饰符和返回类型无关
4、如何区分所要调用方法呢?
*通过参数进行区分
*方法重载的适用场合:
多个方法功能相同，只是参数不同，可以动态根据参数从而区分调用不同的方法
*好处:
*在调用时只需要记住一个方法，从而通过参数进行区分
成员变量与局部变量的区分:
1、所在位置不同:
成员变量在类中，但不在具体的方法中以及代码块中
局部变量在方法中以及在代码语句中
2、初始值不同:
成员变量声明就可以使用，它会默认进行赋值操作
局部变量就必须声明、赋值才能使用（它不存在默认值）
3、在内存中存储位置不同
*成员变量分配到堆内存中
*局部变量分配至栈中
4、生命周期不同
*成员变量随着对象的存在而存在，随对象的销毁而销毁
*局部变量是随着方法调用而存，随着方法销毁而销毁
*对于成员变量为int的默认值为:
0
*对于成员变量为string的默认值为:
null
*对于成员变量为double的默认值为:
0.0
构造方法的特征:
*1、方法名称与类名相同
*2、无返回类型（理解:
调用构造方法返回当前的对象）
*构造方法的作用:
*1、创建类的对象必须显示调用构造方法
*2、可以对类的成员进行初始化
*构造方法可以进行重载
*1、要注意不能无限制进行重载
*2、一个类提供带全参数与无参的构造方法再加相应的set
实现面向对象的封装
*1、属性私有化
*2、提供对应的public的setXxxx（）与getXxx（）的方法
相应提供set与get的方法
*set与get的方法命名规则:
*set+StuName=setStuName（）
*get+StuName=getStuName（）
3、对setXxx（）方法进行合理性限制
静态变量与非静态变量的区别
1、非静态变量单独属于某个对象
2、而静态变量则属于整个类，多个对象共享的
3、静态变量是存储在静态方法区中，而非静态变量则是存储在堆上（成员变量）
问题:
*1、静态变量可以直接用类名调用也可以用对象名来调用（为什么）
*2、静态变量又称之为类变量，静态方法又称之为类方法
*static关键字能修饰哪些成员?
*1、可以修饰成员变量
*2、可以修饰成员方法
*3、可以修饰代码块
java如何进行调试，从而跟踪代码的执行过程
1、定义断点
2、起动调用:
Debugas（javaapplication）
3、进行单步跟踪（F6下一步，F5进入里面进行跟踪）
this关键字
1、this关键代表当前对象
2、使用this关键字区分成员变量与局部变量同名
3、在本类中使用this关键可以调用成员属性与成员方法
4、this关键字可以用来调用构造方法
5、在一个构造方法中通过this关键在调用另一个构造方法时必须出现在第一句代码位置
构造方法重写的条件
*1、在继承中（有父类与子类）
*2、子类中的方法与父类被重写的方法保持签名一致（方法名称相同、参数相同、返回类型相同）
*3、子类重写的方法的访问修饰符要么与父类保持一致但可以大
*4、子类重写的方法不能比父类被重写的方法抛的异常更大,但可以小（要么是异常类的子类）
super关键字
*1、super关键字指向父类对象
*2、通过super关键字可以在子类的构造方法中通过它显示调用父类的构造方法,
*但是必须在子类构造方法的第一句代码位置
*3、通过super关键可以调用父类其他成员，当位置可随意
java中的继承
*1、继承的原则:
要符合is-a关系
*2、父类中是所有子类的共性的成员
*3、子类通过extends父类
*4、java中的继承只支持单一继承
*5、子类继承父类以下则不能继承
*.父类private成员不能继承
*.父类构造方法不能继承
*.如果是默认的访问修饰符不同包的子类不能继承（同包的子类可以继承）
继承的好处:
*1、模拟实现世界中对象与对象之间的关系
*2、提高了代码的重用性
访问修饰符作用域
*private:
本类
*defalutorfriendly:
本类,同包的子类,不同包的子类不可
*protected:
本类,同包的子类可以or同包的非子类也可,不同包的子类可以or不同包的非子类则不可
*public:
all
抽象类abstract有什么作用:
1、模拟现实世界中对象与对象之间的关系
*2、可以适当提高代码重用、对于扩展与维护有利
（1）把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
（2）抽象类的特点
A:
抽象类和抽象方法必须用关键字abstract修饰
B:
抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:
抽象类不能实例化
D:
抽象类的子类
a:
是一个抽象类。
b:
是一个具体类。
这个类必须重写抽象类中的所有抽象方法。
（3）抽象类的成员特点：
A:
成员变量
有变量，有常量
B:
构造方法
有构造方法
C:
成员方法
有抽象，有非抽象
（4）抽象类的几个小问题
A:
抽象类有构造方法，不能实例化，那么构造方法有什么用?
用于子类访问父类数据的初始化
B:
一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象
C:
abstract不能和哪些关键字共存
a:
final冲突
b:
private冲突
c:
static无意义
多态
1、java中构成多态的条件
*.要有继承
*.要有重写
*.父类的引用指向子类的对象（也可以指向父类自身的对象）
（1）同一个对象在不同时刻体现出来的不同状态。
（2）多态的前提：
A:
有继承或者实现关系。
B:
有方法重写。
C:
有父类或者父接口引用指向子类对象。
多态的分类：
a:
具体类多态
classFu{}
classZiextendsFu{}
Fuf=newZi（）;
b:
抽象类多态
abstractclassFu{}
classZiextendsFu{}
Fuf=newZi（）;
c:
接口多态
interfaceFu{}
classZiimplementsFu{}
Fuf=newZi（）;
（3）多态中的成员访问特点
A:
成员变量
编译看左边，运行看左边
B:
构造方法
子类的构造都会默认访问父类构造
C:
成员方法
编译看左边，运行看右边
D:
静态方法
编译看左边，运行看左边
为什么?
因为成员方法有重写。
（4）多态的好处：
1、模拟了现实世界中对象与对象之间的关系
*2、提高了代码的可重用性
*3、提高了程序可扩展性（灵活性）
A:
提高代码的维护性（继承体现）
B:
提高代码的扩展性（多态体现）
（5）多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
多态中的转型
A:
向上转型
从子到父
从子类到父类的类型适用于自动类型转换
*向上转型:
从子类到父类的类型（前提:
要有继承）
*特点：
子类能够访问的层面只能站在父类对象来看，来能看到的只是被子类重写的方法,
*自身所特殊的方法则调用不到。
B:
向下转型
从父到子
向下转型（强制类型转换）
*（子类）父类对象
*存在问题:
可能会产生classcastException（类型转换异常）
*如何避免:
使用instanceof运算符
final关键字
使用final关键字修饰成员属性（常量）
final可以修饰成员方法（表示该方法不能重写）
如果某个类被final修饰了，表示该类不能继承
（1）是最终的意思，可以修饰类，方法，变量。
（2）特点：
A:
它修饰的类，不能被继承。
B:
它修饰的方法，不能被重写。
C:
它修饰的变量，是一个常量。
（3）面试相关：
A:
局部变量
a:
基本类型值不能发生改变
b:
引用类型地址值不能发生改变，但是对象的内容是可以改变的
B:
初始化时机
a:
只能初始化一次。
b:
常见的给值
定义的时候。
（推荐）
构造方法中。
绑定的类型
1、动态绑定:
一定在运行过程中，通过具体的传参才能决定的（后期绑定）
2、静态绑定:
在编译期间就能够决定的（前期绑定）
第4章Java中的接口
1、Java中接口语法
2、语法1:
3、[修饰符]interface接口名extends父接口1,父接口2,…{
4、常量定义
5、方法定义
6、}
7、语法2:
8、class类名extends父类名接口1,接口2,…{
9、类的内容
10、}
接口说明
A.接口和类、抽象类是一个层次的概念，命名规则相同。
如果修饰符是public，则该接口在整个项目中可见。
如果省略修饰符，则该接口只在当前包中可见。
B.接口中可以定义常量，不能定义变量。
接口中属性都会自动用publicstaticfinal修饰，即接口中属性都是全局静态常量。
接口中的常量必须在定义时指定初始值。
1.publicstaticfinalPI=3.14;
2.intPI=3.14;//在接口中，这两个定义语句效果完全相同
3.intPI;//错误,在接口中必须指定初始值，在类中会有默认值
C.接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。
D.一个类只能有一个直接父类，但可以通过implements实现多个接口。
类必须实现接口的全部方法，否则必须定义为抽象类。
类在继承父类的同时又实现多个接口时，extends必须位于implements之前。
E.接口是一种特殊的抽象类
抽象类与接口的区别
A.成员区别:
1.抽象类:
a）成员变量:
可以变量，也可以常量
b）构造方法:
有
c）成员方法:
可以抽象，也可以非抽象
2.接口:
a）成员变量:
只可以为常量
b）成员方法:
只可以抽象
B.关系区别:
3.类与类:
继承，单继承
4.类与接口:
实现，单实现，多实现
5.接口与接口:
继承，单继承，多继承
C.设计理念区别:
6.抽象类:
被继承体现的是is-a的关系。
抽象类中定义的是该继承体系的共性功能。
7.接口:
被实现体现的是like-a的关系。
接口中定义的是该继承体系的扩展功能。
（在许多框架中都采用面向接口编程的思想）
理解
如果说子类继承超类是“isa”，即“是”的关系，类和支持类之间是“hasa”，即“有”的关系，或称“组合”，那么类和接口则是“likea”，即“像是”的关系。
接口表示，所有实现了我这个接口的类都具有我规定的协议，即“看起来都像我”，确切地说，“看起来都像我的签名”
第7章Java中的常用类
包装类
（1）java八个基本数据类型:
byte,char,short,int,long,float,double,boolean
（2）对应的八个包装类型:
Byte,Character,Short,Integer,Long,Float,Double,Boolean
都位于java.lang包中
（3）装箱与拆箱:
（JDK1.5（java5.0）开始支持装箱与拆箱）
A:
装箱:
基本类型-->包装类型（Integera=12）
B:
拆箱:
包装类型-->基本类型（intc=a;）intc=a.intValue（）;
C:
包装类方法:
.xxxValue（）[拆箱],.valueOf（）[装箱]
（4）包装类扩展题:
A:
Integera=newInteger（12）;Integerb=newInteger（13）;
System.out.println（a==b）;
String类（字符串起来形成字符串or字符串是字符的数组）
（1）publicfinalclassString...:
该类不能派生子类（不能继承）
（2）String对象不可变
（3）频繁拼接效率低
（4）常用方法
.intlength（）:
返回字符串的长度方法（字符的个数）,注意与数组length属性区别;
.booleanequals（Objectobject）:
将此字符串与指定的对象比较;
该方法是继承自Object中,String类中对该方法进行了重写,用于比较两字符串对象的值是否相等;（==进行说明）
.intindexOf（...）:
返回指定的字符或字符串在该字符串第一次出现的索引位置
如果存在则返回具体的索引位置,否则返回-1（-1表示不存在）
例如:
邮箱地址中是否存在@与.符号则可以使用indexOf（）方法;
.intlastIndexOf（...）:
.charcharAt（intindex）:
在指定的位置提取单个字符;
.StringsubString（...）:
截取字符串方法;
.Stringconcat（Stringstr）:
拼接字符串（使用"+"做连接）
.Stringreplace（...）:
替换方法
.Stringtrim（）;过滤该字符串前后空格
.StringtoLowerCase（）:
转换为小写
.StringtoUpperCase（）:
转换为大写
.intcompareTo（StringanotherString）:
按字典顺序比较两字符串
.staticStringformat（...）:
格式化字符串
StringBuffer类
String,StringBuffer（JDK1.0）,StirngBuilder（JDK5.0）区别
A:
string不可变,后二者可变;
B:
stringbuffer就线程安全的,而StirngBuilder是线程不安全的;
C:
效率:
StirngBuilder>StringBuffer>String
D:
String、StringBuffer、StringBuilder都是被final修饰的，是不能够被继承改写的
第8章Java中的集合
Collection
List集合
1、List--ArrayList（实现类）
:
一个有序集合,可以允许重复元素、可以存null元素
有序（存储有先后顺序）
ArrayList在哪些场合下使用:
在循环遍历与随机访问时推荐使用
Set集合
set集合的特点:
*1、它是无序
*2、只能存一个null
XX文库-让每个人平等地提升自我*3、不许重复
泛型集合LinkedList
LinkedList集合适应场合:
对于频繁插入与删除则选它
Map集合（key,value）
HashMap:
特点
*1、用于key--value对应的关系
*2、键不允许重复（如果重复会发生覆盖）,值可以重复
第9章JAVA中的流
1、File类
2、java中的流
（1）java中操作流的类都位于:
java.io中
（2）流的分类
A:
按照流的流向分:
输入流与输出流
.输入流:
只能从中读取数据,而不能向其写出数据;
.输出流:
只能向其写出数据,而不能从中读取数据;
.说明:
数据从内存到硬盘,通常称为输出流,这里的输入、输出都是从程序运行所在
内存的角度来划分的。
B:
按照处理的数据单元不同:
.字节流:
字节流操作的最小数据单元是8位字节。
.字符流:
而字符流操作的最小数据单元是16位字符。
C:
按照流的角色:
.节点流:
节点流也被称为低级流;（可以从/向一个特定的IO设备[如磁盘、网络）读/写数据的流）
.处理流:
用于对一个已存在的流进行连接或封装,通过封装后流来实现数据读/写功能。
（3）字节流与字符流
A:
字节流
.InputStream:
字节输入流;
.OutputStream:
字节输出流;
B:
字符流
.Reader:
字符输入流;
.Write:
字符输出流;
3、字节流与字符流的具体类
（1）FileInputStream
（2）FileReader
（3）FileOutputStream
（4）FileWrite
4、转换流
（1）输入/输出流体系里还提供了2个转换流,这两个转换流用于实现将字节流转成字符流,
其中InputStreamReader将字节输入流转换成字符输入流,OutputStreamWriter将字节
输出流转换成字符输出流。
序列化
（1）序列化的含义:
序列化机制允许将实现序列化的java对象转换为字节序列,这些字节序列可以保存至磁盘上或通过网络传输,以备以后重新恢复成原来对象。
序列化机制使得对象可以脱离程序的运行而独立存在。
（2）如何实现对象序列化
序列化操作:
A:
将类实现序列化接口（Serializable）
B:
创建一个ObjectOutputStream输出流
ObjectOutputStreamoos=newObjectOutputStream（newFileOutputStream（"Object.txt"））;
C:
调用ObjectOutputStream对象的writeObject方法输出可序列化对象
Personper=newPerson（.........）;
oos.writeObject（per）;
反序列化:
A:
创建一个ObjectInputStream输入流
ObjectInputStreamois=newObjectInputStream（newFileInputStream（"object.txt"））;
B:
调用ObjectInputStream的readObject方法读取流中的对象
Personperson=（Person）ois.readObject（）;
sysout（person.getPerName（）+"\t"+person.getPerAge）
第10章JavaGUI和swing
swing体系:
（1）JFrame:
Object
|--Component
|--Container
|--window
|--Frame
|--JFrame
swingpkawt
（1）使用swing来开发图形界面比awt更加优秀,因为swing是一种轻量级组件,它采用100%的java实现,不再依赖于本地平台的图形界面,所以可以在所有平台上保持相同的运行效果,对跨平台支持比较出色。
（2）swing提供了比awt更多的图形界面组件,因此可以开发出更美观的图形程序。
由于awt需要调用底层平台的GUI实现,所以awt只能使用各种平台上GUI组件的交集,这大大限制了awt所支持的GUI组件,而swing则不存在此问题。
（3）除此之外swing组件都采用了MVC（model-view-controller）的设计从而实现GUI组件的显示逻辑和数据逻辑分离。
第14章多线程
1、进程
（1）进程是系统进行资源分配的一个独立单位;
进程就是正在运程的程序;
（2）进程的特征:
A独立性:
每一个进程都拥有自己私有的空间。
B动态性:
进程是一个正在系统中活动的指令的集合。
C并发性:
多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。
并发性是指同一时刻只能有一条指令执行,但多个进程指令被快速轮换执行使得宏观上具有多个进程同时执行的效果。
并行性:
2.线程
（1）一个进程中至少有两个线程（两个或多个线程）
（2）java多线程:
A:
进程是系统资源分配的独立的单元;
B:
进程是重量级的（它有独立内存资源空间）
C:
进程之间的资源共享会带来诸多麻烦
（3）为何java中使用多线程进行操作
A:
线程是轻量级的,它可以共享同一个进程中的资源;
3.java中多线程的开发
（1）Thread（线程）类
a:
自定义一个子类extendsThread类
b:
重写run（）方法
c:
创建线程类的对象
d:
调用start方法启动线程
（2）Runnable（接口）
（3）汽车站有三个窗口,共售100票,使用线程进行处理
4、线程中的生产者与消费者
升级会员 