全面的面向对象知识点DOC.docx
- 文档编号:26588812
- 上传时间:2023-06-20
- 格式:DOCX
- 页数:27
- 大小:26.82KB
全面的面向对象知识点DOC.docx
《全面的面向对象知识点DOC.docx》由会员分享,可在线阅读,更多相关《全面的面向对象知识点DOC.docx(27页珍藏版)》请在冰豆网上搜索。
全面的面向对象知识点DOC
成员变量的特点:
1、成员变量有默认值
引用类型:
null
基本类型:
整数:
byte0short0int0long0L
小数:
float0.0Fdouble0.0
布尔:
false(true)
字符:
用的unicode'\u0000'
2、成员变量VS局部变量
共同点:
都是变量,用于保存可变的数据格式:
类型变量名;
既然是变量都应该满足java标识符的规则
不同点:
局部变量在使用之前必须初始化,而成员变量自动在定义的时候就初始化(默认值见上)
作用域不同,局部变量在包含自身的函数或者代码块中有效,而成员变量在整个类中有效
在内存中的区域不同,局部变量在栈中,成员变量在堆内存
访问方式不同,局部变量可以通过变量名直接访问,成员变量必须以来于(实例.)来访问
细节:
调用函数的时候,需要注意的是如果函数有返回类型,那么可以调用打印语句将
返回的数据进行输出,反之,编译出错!
匿名对象的特点:
1、创建实例的方式new类();
2、访问属性的方式2种:
Stringcolor=newCar().颜色;
System.out.println(newCar().颜色);
3、匿名类创建的实例的有效范围是匿名类创建结束
4、使用匿名类改变实例的属性是不可取的,因为改变之后该实例访问不到(每个对象用完之后就消失)
5、匿名类的使用范围:
函数的调用和实参的传递
使用场景:
函数的调用:
当只需要调用一次类的成员函数的时,可以采用匿名类,多次调用必须起名字。
实参的传递:
当开发者创建一个实例只是想要将该实例作为实际的参数传递给函数,那么就可以使用
封装的概念:
1.封装即在描述一个类的时候,将原来的逐步的功能(面向过程),组装进类中。
属性和函数
2.封装
2.1属性的封装
实现:
将属性的访问权限设置为private,然后提供共有的访问方法
对于属性而言,要提供getXxx()和setXxx()
2.2函数的封装
实现:
函数本身就是封装,因为函数本身就是一个具有特定功能的函数
函数也称之为:
功能
封装的实现:
属性封装:
将类中的成员属性设置为私有的访问方式,对外提供公有的访问权限
封装的好处:
1、将变化隔离
2、便于使用
3、提高代码的复用性
4、提高代码安全性(记忆)
构造函数:
就是一个普通的用来对类进行初始化操作的函数
构造器的特点:
1、在描述一个类的时候,类本身有一个默认的无参数的构造函数
2、构造函数没有返回值类型,但是也不能写void
3、构造函数的名称和类名一致
4、一旦开发者自己定义了构造函数,那么编译器就不会自动给类添加默认的无参数的构造函数
5、构造函数可以按照函数重载的形式出现(最常见的重载的例子)
6、在一个构造函数中不能以一般的调用函数的方式来调用构造函数
new
7、没有return
应用:
构造函数主要在初始化的时候调用
注意:
1、定义变量的时候可以初始化,优先级最高(加载类)
2、构造函数也可以初始化成员变量,只不过覆盖1中的值
代码块:
使用{}括起来的一些java语句
分类:
在函数中:
局部代码块
在类中:
构造代码块
特点:
1、按顺序执行
2、可以嵌套
3、变量不能冲突,但是可以在变量释放后再定义同名的变量
4、先是默认初始化inta;再是显示的初始化inta=23;
构造代码块初始化{a=45}构造函数初始化a=67;
区别:
构造代码块给所有的实例初始化
构造函数是给特定的对象进行初始化
项目应用:
可以将多个实例都需要初始化的变量放在构造代码块中一次性初始化
可以提高代码的效率
this关键字:
该关键字主要用来解决局部变量和成员变量之间的命名冲突问题
this用法:
this.成员变量|函数
使用细节:
1、可以调用成员
2、调用构造函数格式:
this(//构造函数的参数列表);
注意:
使用this调用构造函数的时候一定要放在第一行
因为实例的初始化工作要先进行
构造函数中不允许递归的出现(自己调用自己称作递归)
A调用BB又调用A,也就递归(注意这里的AB都是构造函数)
Static关键字:
类变量:
属于类,而且需要使用static修饰,
作用范围:
可以用来修饰属性、函数和类,还可以修饰代码块
特点:
所有的实例都共享一份
成员属性可以通过实例访问
还可以通过类名直接访问(核心的特点)
静态方法中只能调用静态的成员,不能使用非静态成员(变量和函数),
但是定义自己的局部变量是允许的
静态函数中不能使用this、super关键字
------------------------------------------------------------------------------------
main()函数简介:
publicstaticvoidmain(String[]args){....}
分析:
1、该函数是由JVM帮助开发人员调用的
2、该函数的名称必须是main
public:
控制该函数的访问的权限,其他的类都可以调用,直接通过类名来访问
static:
说明该函数是一个静态函数,可以使用类名直接访问,也可以通过对象来访问
void:
说明该函数没有计算的结果
main:
函数名称可变,但是JVM只认识main(),如果没有则抛出异常如:
//java.lang.NoSuchMethodError
String[]:
函数的形参,args可变,也可以写为可变参数的形式:
publicstaticvoidmain(String...args)
注意:
如何给虚拟机传递main函数的参数:
javaDemo534455678
原理:
将class文件后的参数以“”分割后组装成为一个String类型的数组传递进去
静态代码块:
主要用于对静态成员变量进行初始化,当类被加载的时候执行,而且执行一次
格式:
static{...}
需求:
请以不同的方式打印helloworld
总结:
类的初始化过程:
---------------------静态初始化-------------------------
1、类被装载
2、类的静态变量先做默认的初始化工作staticinta;//0
3、编译器对静态变量进行显示的初始化工作staticinta=90;//90
4、类的静态代码块对静态变量进行初始化
---------------------非静态初始化-------------------------
5、类的非静态成员进行默认的初始化工作inta;
6、类的非静态变量进行显示的始化工作inta=8;//8
7、类的构造代码块对非静态变量进行初始化工作
8、类的构造函数对非静态变量进行初始化工作(创建对象时)
单例设计模式:
java中借鉴了工程的一些设计的思想
java中就有一些常见的设计模式(解决一类问题的思想或者方案)
java的设计模式23种(书籍)
单例的设计模式:
为什么要使得一个对象是单个的:
为了避免堆内存中过多的垃圾对象(如果对象过多,会导致内存溢出)
默认的堆内存的空间是64M
单例模式:
1、将类的构造函数私有化(private)
2、创建一个类类型的变量,使用私有的构造函数来初始化
3、对外提供获取对象的共有的方法
4、将所有的成员定义为static的
单例的实现方式:
1、饿汉式
privatestaticServerser=newServer();
2、懒汉式
classServer
{
/*饿汉式
privatestaticServerser=newServer();//属性
privateServer(){//私有的成员只能在本类中使用
}
publicstaticServergetInstances(){//成员函数
returnser;
}
*/
//懒汉式
privatestaticServerser=null;//属性
privateServer(){//私有的成员只能在本类中使用
}
publicstaticServergetInstances(){//成员函数
if(ser==null){
ser=newServer();
}
returnser;
}
}
/*
继承:
继承主要用来解决类和类直接的重复代码问题
实现:
extends(扩展)
应用:
1、不要为了继承而继承
2、当父类中所有的成员子类都需要的时候,可以使用继承
如果父类中有一些某些子类不需要的成员,那么就不能单独的为了代码的共享而继承
细节:
1、private修饰的成员无法被继承
2、java中是单继承(同时只能扩展一个类),但是可以通过接口来完成多实现
继承的特点:
1、属性
1.1子类可以直接继承父类的非私有的成员属性(private)
1.2子类可以通过super关键字来获取父类中定义的与子类同名的成员
1.3子类可以通过默认的调用this或者super来调用父类的静态成员
-----------------------------------------------------------------------------------------------
2、函数
2.1子类可以直接调用父类的非private的成员函数
2.2子类可以定义和父类相同的函数,称之为覆盖(Override)|重写
如果调用子类的函数,则执行子类重写后的函数,如果调用父类的使用super关键字。
如:
super.show()
2.3子类中的函数不能使用this关键字调用自己(递归)
2.4函数的重写需要函数的声明完全一致(包括函数的返回类型)
2.5如果父类是静态的函数,那么子类也必须使用静态的函数进行重写,否则会访问父类的
静态函数
重写:
(Override)
1、函数名必须一致
2、参数列表必须一致
3、返回类型必须一致
4、如果是static的必须相同
5、修饰符只能大于等于父类
父默认子默认public
父public子public
父private子不能继承
6、子类抛出的异常必须小于等于父类的异常
父A子A也可以抛出A的子类
重载:
(Overload)
1、函数名要相同
2、参数列表不同
final:
最终的、最后的
作用范围:
可以用来修饰类、函数、变量(成员变量、局部变量)
修饰类:
标志该类不能被继承;无法从最终Person进行继承
什么样的类应该被修饰为final的?
1.1所有的工具类应该被修饰为final(一般情况)
1.2字符串类中所有方法都是对字符串进行操作的,那么其他的类进行重写是没有意义
如果一个类的功能都是完成自身的对象的一些操作,那么该类也可以是final的
如:
String
1.3如果该类的功能不需要被其他类进行继承(扩展)的化,那么也可以修饰为final
修饰函数:
标志函数不能被重写:
Zi中的function()无法覆盖Fu中的function();被覆盖的方法为fi
应用:
当父类的功能和子类是一致的,而且不能让子类来重写,那么该函数就可以被
final修饰
修饰变量:
成员变量:
1.1如果final用来修饰成员变量,那么该变量就会变为常量,并且需要赋初始化值
finaldoublemoney=34.0;
1.2一旦给常量赋值了,那么该常量就不能被改变(值)
局部变量:
1.1当final修饰局部变量时,当作常量来使用
1.2面试题:
请问final是否可以修饰形式参数?
yes
为什么要使用final来修饰实参?
因为该参数在局部的函数中不需要被修改,这样可以提高代码的效率
注意:
当类中定义了一个局部内部类,那么局部内部类中只能访问final的变量
如:
classA{
voidshow(){
inta=90;
classB{//局部内部类
//a=34;报错
}
}
}
抽象类:
使用abstract修饰的类称之为抽象类
特点:
1、抽象类不能被直接实例化:
是抽象的;无法对其进行实例化
2、如果抽象类中有抽象的函数,那么继承该抽象类的子类必须实现父类的所有的抽象函数
或者把自己(子类)也声明为抽象类
3、包含抽象函数的一定是抽象类
抽象类中不一定包含抽象函数
4、只能被继承
注意:
定义抽象函数的时候,一定不能有{}其实{}代表实现,没有{}就是函数没有实现
应用:
1、当父类不确定子类的具体的实现方式时,可以将父类中的该函数定义为抽象的
抽象==未知|不确定
那么该类就一定是抽象类
作用:
1、可以将未知的实现抽取出来统一定义为抽象类
2、可以强制子类实现父类没有实现的函数
3、使用抽象类编程可以提高代码的扩展性
模板设计模式:
测试代码的执行时间:
思想:
代码执行前看表1
代码执行后看表2
看表2-看表1
实现:
看表
模版方法设计模式:
模版:
1、根据具体的需求写出实现功能的模版代码
2、抽取模版代码中的可变部分作为抽象方法
3、在模版代码中调用抽取出来的抽象方法
4、将模版代码抽象为一个普通的方法
5、将模版方法和抽象方法会抽取为一个抽象类
6、将模版方法设置为final修饰的
7、在测试类中继承抽象类,实现抽象方法,调用模版方法
接口:
(interface)
接口:
就是一个特殊的类,该类使用interface来定义
格式:
interface接口名{}
接口的实现:
使用implements关键字来实现接口
特点:
接口的函数都是publicabstract,所以接口不能使用new关键字来创建实例
1、接口中定义的变量默认加publicstaticfinal,那么就是静态常量,那就必须要初始化,
而且该值不能被修改
2、接口中定义的函数默认加publicabstract,那么就抽象函数,那就不能使用{},
而且该值不能被修改
3、接口可以多实现,而且实现的接口之间使用","隔开
4、接口只能继承接口
5、类、抽象类用来实现接口
6、ABC是三个接口,B继承AC继承B
D是一个实现类(可以直接被实例化的类)而且实现了C
那么D中有ABC中的所有的功能
D=C=B=A
注意:
1、开发者可以自己显示的使用默认的修饰来修饰接口,但是必须和默认的一致
2、一个类可以实现多个接口并继承单个类
如:
classDextendsCimplementsA,B
注意:
先继承后实现
应用:
1、如果类需要多重继承的时候,可以使用接口来多重实现
2、当一个类中需要扩展功能时,可以将该功能定义在接口中
多态:
对象的多种表现形态
你:
人男人儿子学员公民外国人
多态的表现形式:
类:
类和类之间有关系isa
男人isa人继承关系
必要条件:
多种形态之间必须要有继承关系
表现形式:
儿子a=new儿子();
男人b=new儿子();//多态的表现形式
父类的引用指向子类的实例
作用:
提高代码的复用性
扩展性很好
特点:
1、函数(核心)
编译时
1.1多态在编译时,自动检测函数是否被引用用的类型包含,如果不包含,出编译出错
运行时
1.2如果子类重写了父类的函数,那么在多态情况下,调用的函数是子类重写的函数
1.3如果子类没有重写父类的函数,那么在多态情况下,调用的函数是父类的函数
2、静态函数
2.1静态函数的调用取决与引用变量的类型
3、非静态属性
3.1和非静态函数一致
4、静态属性
3.3首先调用自己的,(先调用引用类型变量所属的类的变量)(焦老师讲课时,用父类引用调用子类的非静态方法,而非静态方法内部包含了对静态成员变量,所以输出是子类的静态变量值,如果用父类引用掉用静态成员变量,则结果输出是父类的静态成员变量的值)
"哈雷还是哈雷"
多态中的转型和instanceof关键字
多态中的转型:
基本数据类型的转换:
int--long自动小类型转大类型是自动的
long--int强制大类型转小类型是强转的注意:
会损失精度
类之间的类型转换:
前提是多态
1、子类转父类自动转换
2、父类转子类强制转换格式:
子类子=(子类)父类
-------------------------------------------------------------------------------
需求:
如何来判断一个引用变量指向的实例是属于哪个类的
instanceof关键字:
instanceof判断一个引用变量是否是某一类的实例
特点:
子类的引用变量永远是父类的实例
子类的引用变量instanceof父类永远是true
Object:
默认是所有类的终极父类
Object的父类是谁?
没有
常见方法:
toString():
当直接打印一个对象的引用变量时,JVM默认调用该方法
对类进行描述和说明的
格式:
类型@内存的哈希码
注意:
开发者在定义类的时候应该重写该方法,使得打印的信息更加容易描述类
hashCode():
返回对象的内存地址的hashcode编码,需要通过integr的toHexString()将其转换为0x
equals():
用于判断对象在内存中的地址是否相等(默认是使用==来实现)
如果开发者要判断对象的属性是否相等,那么需要重写Object的equals()
注意:
java规范中定义,两个对象如果equals()返回true,那么要求开发者也要重写
hashCode().
习惯:
当开发者定义类的时候,首先要考虑的是是否要重写Object的方法?
习惯:
以上的3个方法都要重写
场景:
买猫?
逛街卖猫(3只1500)张三你
问题:
具体的对象,对象是不是相等?
常用?
常用
内部类:
顾名思义内部的类,也叫做嵌套类(innerclass|nestedclass)
格式:
在类的成员位置可以直接定义一个类,把成员位置上的类,称作成员内部类
分类:
1、如果在类的成员位置定义了另外一个类:
称作:
成员内部类
特点:
可以访问外部类的所有的成员属性(private)
可以使用private修饰,只有外部类可以访问
直接调用内部类的成员函数的格式:
外部类.内部类变量=new外部类().new内部类();
变量.函数名();
2、如果在类的成员位置定义了另外一个静态类:
称作:
静态内部类
特点:
无法从静态的上下文中使用this,super或者实例的成员
如果内部类中存在静态成员,那么内部类必须声明为静态的
3、如果在类的函数中定义了另外一个类:
称作:
局部内部类
优点:
使得包含局部内部类的功能更加明细
细节:
在包含局部内部类的函数中创建局部内部类的实例要写在局部内部类定义的后面
在局部内部类中为了代码的安全性只能访问包含局部内部类的函数的常量,但是
可以直接访问外部类的成员
4、局部静态类(不存在)
特殊:
在局部内部类中不存在内部类被修饰为private或者static
匿名内部类:
interfaceC
{
intx=3;
abstractvoidshow();
}
classA
{
/*
classBextendsC
{
voidshow(){
System.out.println("x="+x);
}
}
*/
voidfunction(){
//Bb=newB();
//b.show();
newC(){
publicvoidshow(){
System.out.println("x="+x);
}
}.show();//匿名内部类
}
}
classDemo8
{
publicstaticvoidmain(String[]args)
{
/***************************************************************************************************/
/*
匿名内部类:
指的的是在创建内部类的时候不使用引用变量进行指向,而不是描述内部类的时候不起
名
前提:
成员内部类必须继承或者实现某一个特定的抽象类或者接口
特点:
1、可以在创建内部类实例的时候取消内部类的定义
2、只适合在抽象类或者接口中有少量的未实现的函数上使用
*/
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 全面 面向 对象 知识点 DOC
![提示](https://static.bdocx.com/images/bang_tan.gif)