java面向对象总结Word文档下载推荐.docx
《java面向对象总结Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《java面向对象总结Word文档下载推荐.docx(43页珍藏版)》请在冰豆网上搜索。
![java面向对象总结Word文档下载推荐.docx](https://file1.bdocx.com/fileroot1/2023-1/8/55e2f168-9dda-4b6c-bc97-340520c2e25b/55e2f168-9dda-4b6c-bc97-340520c2e25b1.gif)
类也是一个封装体。
private:
私有的,权限修饰符,用来修饰类中的成员(成员变量、成员函数),其只在本类中有效。
每个成员变量通常都会对应两个访问方式:
一个设置,一个获取。
注意:
私有仅是封装的一种表现形式。
因为语句都必须在函数内,所以,私有化后,再提供访问方式,就可以在访问方式的函数内实现变量控制。
这样就提高代码的健壮性。
一般进行封装,要对类中的大部分属性都隐藏,最低权限是private。
类里有一个setXxx函数(一般返回值是void,直接获取,要带参数)和getXxx函数(有返回值类型,但一般没参数,getXxx之后一般用一个变量来接收:
stringx=p.getXxx
),那代表一定有一个私有化属性。
成员变量都有初始化值,局部变量可以没有。
举例:
classXueSheng
{
privateStringname;
publicvoidsetName(Stringname)//这个函数方便以后赋值
{
this.name=name;
}
publicStringgetName()//这个函数是方便以后有需要调用的,比如以后要打印name的值
returnname;
封装的好处:
1、提高程序中代码的复用性、程序在后期维护方便
2、程序中代码的安全性提高:
隐藏事物的部分细节,但是需要对外提供可以访问隐藏细节的方式(函数)
构造函数:
函数名与类名一致,不用返回值类型,不可以用return,主要用来初始化对象。
对象一建立,就默认调用其构造函数。
一个对象一建立,就有其默认的属性和行为。
(如一个人刚出生就会呼吸,哭...)。
如果我们没有指认,那么类建立就会默认建一个构造函数(类名(){}),不然对象无法初始化,也就无法建立。
(注意:
只要我们有指认,那么就不会默认建构造函数)
其与普通函数的区别除了写法上之外:
1,构造函数只在对象建立时运行一次,不再运行了,而普通函数可以调用多次,另外,构造函数是用来初始化对象的,而一般方法是用来添加对象具备的功能。
何时我们要手动添加构造函数:
当我们分析事物时,该事物存在一些特性或行为,那么我们就给其定义一个构造函数,如果有变量参与运算,那么我们就给构造函数定义一个参数。
构造函数写法举例:
classPerson
Person(Stringname,intage)
//注意:
在新建一个对象时要加上参数进行区分,因为一个类可以放很多个构造函数。
//比如:
Personp=newPerson("
fada"
20)
this.name=name;
this.age=age;
构造代码块:
1,所有对象在建立时都先执行构造代码块初始化,再执行构造函数初始化。
2,作用:
当所有对象有共性时,那么就可以定义一个构造代码块(例如:
所有小孩先出来就是哭,然后才有其它的属性)
构造代码块的写法(就是在类里面用一个大括号)举例:
System.out.print("
//这样一写,那么以后每次建立一个构造函数时便先初始化这个构造代码块
}
this关键字的用法
this在类中就是三个代表:
代表对象的成员变量,在函数中代表对象调用函数,代表类中的构造函数。
this.变量=变量;
this是用来区分局部变量和成员变量同名时的关键字,因为如果在构造函数里比如(name=name),那么其是赋值给他本身,而不是赋值给类里面的name。
何时用this?
当定义类中的函数时,需要调用该函数的对象时,这个时候就用this来表示这个对象。
但凡本类功能内部使用到了本类对象,用this表示。
看到this就是有代表对象,代表哪个对象就看其所在功能被哪个对象调用。
这样就知道谁在参与运算。
privateStringname;
Person(Stringname)
//this.name=p1.name;
classPersonDemo3
publicstaticvoidmain(String[]args)
Personp1=newPerson("
);
this的应用之定义类中函数的调用:
当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
但凡本类功能内部使用了了本类对象,都用this表示。
privateStringname;
this.fada();
//其实就==p1.fada();
//这里写这p1是因为p1这个对象在调用这个函数。
一句话,谁调用它就在代表谁。
privateintage;
Person(intage)
this.age=age;
publicvoidfada()
System.out.println("
/*
需求:
给人定义一个用于比较年龄是否相同的功能。
也就是是否是同龄人。
*/
publicbooleancompare(Personp)
{
returnthis.age==p.age;
classPersonDemo
Personp1=newPerson(20);
Personp2=newPerson(25);
//因为是两个人比,所以要先建立两人的对象
booleanb=pare(p2);
//这里定义了一个布尔型变量去接收p1调用compare函数的值
System.out.println(b);
另一种this用法:
格式this(变量)
用于构造函数间的相互调用,而且只能放在构造函数的第一行。
然后先初始化其this调用的构造函数,再初始化本身的构造函数。
其实this(变量);
=new构造函数名(变量);
(因为所有构造函数名是一样的,都是重载函数,所以,通过变量来标记构造函数,用this去引用)
privateintage;
Person()
personrun"
this();
this.name=name;
Static(静态)关键字:
static是一个修饰符:
三种修饰:
修饰类的变量、方法和构造代码块。
静态方法只能直接引用和访问静态变量和方法
注意(函数即方法,对象也叫实例)
有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。
通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。
在成员的声明前面加上关键字static(静态的)就能创建这样的成员。
如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象。
你可以将方法和变量都声明为static。
static成员的最常见的例子是main()。
因为在程序开始执行时必须调用main(),所以它被声明为static。
声明为static的变量称为静态变量或类变量。
可以直接通过类名引用静态变量,也可以通过实例名来引用静态变量,但最好采用前者,因为后者容易混淆静态变量和一般变量。
静态变量是跟类相关联的,类的所有实例共同拥有一个静态变量。
关键点:
静态变量与实例变量的区别:
静态变量也叫类变量,为所有对象所共有,所以一个对象的变量值改变,那么所有对象的值一起发生改变。
而实例变量则是各自独立的不受影响。
声明为static的方法称为静态方法或类方法。
静态方法可以直接调用静态方法,访问静态变量,但是不能直接访问实例变量和实例方法。
静态方法中不能使用this关键字,因为静态方法不属于任何一个实例。
静态方法不能被子类的静态方法覆盖。
特有属性随着对象存储于堆内存中,而static修饰后的属性,存在于方法区.
什么时候使用静态修饰符?
当对象中出现共享数据时,使用静态修饰。
但对象内的特有数据要定义成非静态存在于堆内存中。
而对于方法时:
当功能内部没有访问到非静态数据时,(即对象的特有数据)
那么可以使用静态修饰。
静态代码块:
用于给类做初始化的。
不管有没有对象都执行,只要调用了类里面成员或方法,就会执行,而且优先于主函数,优先执行级别最高。
classJingTai
staticintage;
staticStringname;
static//静态代码块初始化类的,所以最先运行。
name="
+name);
//下面是构造代码块,第二个运行
age="
+age);
publicstaticvoidjing(intx)//被对象调用,第三个运行。
x=age+1;
//因为age是静态的,所以能调用
x="
+x);
classFaDa
publicstaticvoidmain(String[]args)
JingTaip=newJingTai();
p.jing
(2);
文档注释:
文档注释有编译工具进行,具体一个要注意的地方是:
类名前必须要有public修饰。
要编译的方法名必须有public修饰
javadoc注释标签语法
@author对类的说明标明开发该类模块的作者
@version对类的说明标明该类模块的版本
@see对类、属性、方法的说明参考转向,也就是相关主题
@param对方法的说明对方法中某参数的说明
@return对方法的说明对方法返回值的说明
@exception对方法的说明对方法可能抛出的异常进行说明
命令是:
javadoc-d存放目录名称-author-version类名.java
/**
这是一个静态修饰符static的应用说明
@author李四
@versionV1.1
*/
这是一个测试类
publicclassJingTai
/**
空参数构造函数
age一个整数型变量
publicstaticintage;
name一个字符串型变量
publicstaticStringname;
static
打印x的值
@paramx接收一个int型整数
publicstaticvoidjing(intx)
main方法作为程序入口,应该在public的类Test中定义
设计模式:
做一个模式,使其能解决一类问题,这样,碰到类似的问题,直接套就可以了。
java中23种设计模式:
单例设计模式:
解决一个类在内存只存在一个对象。
不再新生成。
思路:
1,为了避免其他程序过多建立该类对象。
先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
步骤:
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
两种方式:
饿汉式
classEr
privateEr(){};
privatestaticEre=newEr();
publicstaticErgetEr()
returne;
懒汉式
privatestaticEre=null;
if(e==null)
e=newEr();
虽然懒汉式可以延迟加载对象,但为代码的简洁性和安全性,日常用的还是饿汉式。
继承
继承就是将两个类的共性描述提取出来,单独进行描述,从而简化代码,提高复用性。
class子类名extends父类名
关健字为extends:
判断两个类是否有所属关系,那么我们就继承一下,看父类所具有的内容属性,子类是否全都需要具备。
如果是,那么他们所属关系成立,就是继承。
千万不要为了获取其他类的功能,简化代码而继承。
必须是类与类之间有所属关系才可以继承。
所属关系isa。
例如:
classA
//voiddemo1(){}
voiddemo2(){}
classB
voiddemo3(){}
我们可以让B继承下A,但发现,A中还具有demo2这个方法是B所不具备的,所以他们俩的继承关系不成立,但我们可以把两个类的共性提取出来,成为一个
classC
voiddemo1(){}
那么A和B就能够继承C,这样就实现在代码的简化和复用。
Java语言中:
java只支持单继承,不支持多继承。
因为多继承容易带来安全隐患:
当多个父类中定义了相同功能,
当功能内容不同时,子类对象不确定要运行哪一个。
但是java保留这种机制。
并用另一种体现形式来完成表示。
多实现。
java支持多层继承。
也就是一个继承体系
如何使用一个继承体系中的功能呢?
想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系中共性功能。
通过了解共性功能,就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时,要创建最子类的对象,为什么呢?
一是因为有可能父类不能创建对象,
二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。
简单一句话:
查阅父类功能,创建子类对象使用功能。
子父类出现后,类成员的特点:
类中成员:
1,变量。
2,函数。
3,构造函数。
1,变量
如果子类中出现非私有的同名成员变量时,
子类要访问本类中的变量,用this
子类要访问父类中的同名变量,用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。
classFu
intnum=4;
classZiextendsFu
intnum=5;
voidshow()
System.out.println(super.num);
//有super对象调用函数打印结果是4,没有打印结果是5
子父类中的函数另一个特性:
函数的重写(覆盖)
当子类继承父类,沿袭了父类的功能,这时不但可以保留父类的功能定义,还可以重写功能内容。
覆盖要注意的关健点:
1,子类覆盖父类,必须保证子类访问权限大于等于父类权限,才可以覆盖,否则编译失败。
(权限修饰符没设的时候为默认权限,介于public与private之间。
classFu
fushow"
java"
//这里我即可以改变,也可以增加。
增加时我们不用重写一遍父类函数的内容,只虽要super.函数名()就可以。
2,静态只能覆盖静态。
重载:
只看同名函数的参数列表。
重写:
子父类方法要一模一样。
子父类中的构造函数之特点:
子类中的构造函数会默认调用父类中的函数中的默认构造函数,因为子类的构造函数默认第一行有一条隐式的语句super();
但有几个地方要注意:
Fu()
如果没有这一个空参数的构造函数,但又有我们指认的非空参数的构造函数,那么我们知道默认那个空参数构造函数也不会生成,这个时候子类就会编译失败。
这个时候就不能让子类默认获取super();
而要指认super(x)
num=60;
furun"
Fu(intx)
fu...."
Zi()
super();
//不管父类有几个构造函数,只要没有指认,那么就默认这一个super();
//super(4);
System.out.println("
zirun"
Zi(intx)
super(3);
zi..."
调用构造函数用super();
(括号里面是参数),而调用一般函数用super.函数名()
一个构造函数中只能要么有this要么有super,而且必须放在第一行
子类中至少会有一个构造函数会访问父类中的构造函数。
extendsObject:
java中的顶极父类,也就是任何没标明父类的类的默认父类。
final:
“最终”修饰符:
1,可以修饰类,函数,变量。
2,被final修饰的类不可以被继承。
作用:
为了避免被继承,被子类复写功能。
3,被final修饰的方法不可以被复写。
4,被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,有可以修饰局部变量。
当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字。
方便于阅读。
而这个值不需要改变,所以加上final修饰。
作为常量:
常量的书写规范所有字母都大写,如果由多个单词组成,单词间通过_连接。
5,内部类定义在类中的局部位置上是,只能访问该局部被final修饰的局部变量。
finalintx=4;
那么x永远等于4,不可以被赋值,就成了常量,之所以不直接定常量,是因为要给数值起个名,增强阅读性,以后也好调用。
抽象
修饰符,abstract:
只能修饰类和方法:
特点:
1,修饰的类不能创建对象(实例)。
2,修饰的对象只有功能,没有内容。
3,抽象方法和抽象类都必须被abstract关键字修饰,也就是抽象方法一定在抽象类中,
但抽象类不一定要有抽象方法.
4,抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用。
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
因为抽象方法和抽象类都必须被abstract关键字修饰(如果只复写了一个,那么子类必然还继承了其它的抽象方法,根据抽象方法必须在抽象类中,则这个类还是个抽象类)。
应用:
1,建立不可创建对象的类。
2,如果子类中需要的方法内容不一样,但又同样都要这么方法,那么就可以创建一个抽象类。
创建一个学校成员,有学生,有老师,都有姓名,年龄,都要上课,但老师上课是教学,学生上课是学习。
所以可以这样写:
classXueXiao
privateintage;
XueXiao(Stringname,intage)
}
publicabstractvoidwork();
//子类需要这个功能,但内容不一样,所以用抽象。
classStudentextendsEmployee
Student(Stringname,intage)
super(name,age);
//直接调用父类构造函数。
publicvoidwork()
shangke"
classLaoShiextendsEmployee
LaoShi(Stringname,intage)
sup