JavaSE之面向对象知识点总结
文章目录
一、面向对象的基础
1.面向对象
(1)Java语言:就是一种面向对象编程语言。
(2)面向对象本质其实就是面向过程(基于面向过程)。
(3)面向过程:代表语言,C语言。
(4)面向对象思想特点:
1)符合现实生活中的思想行为习惯。
2)让我们从执行者变成了指挥者。
3)让复杂的事情简单化。
2.面向对象的设计原则
需要不断的创建对象,使用对象,指挥对象做事情
举例:Scanner类:键盘录入
3.事物
(1)定义:描述现实世界真实存在的
(2)举例:人----事物
长方形—事物
(3)剖析:人
属性:年龄,身高,性别,体重,姓名…
行为:不断的学习…/基本的人具备的…
4.Java中最基本的单元:class 类
(1)定义:描述现实世界一类事物的一组属性和行为的集合。
(2)对象:对象是类的一个实例,具有状态和行为。
(3)类与对象的关系:类是对象的抽象,对象是类的实例。
(4)标准类的组成:成员变量、成员方法、构造方法
(5)成员变量:现实事物的属性,定义方式与局部变量相同,只是成员变量定义在类中、方法外。
(6)成员方法: 成员方法其实就是我们前面讲过的方法去掉static关键字。
举例:public void study(){
System.out.println("人都需要学习...") ;
}
(7)创建对象的格式:
类名 对象名 = new 类名() ;
(8)成员变量的调用与赋值 :
对象名.成员变量= 值;
(9)成员方法的调用:
对象名.成员方法名() ;
5.类的组成及其可以用的修饰符
(1)类:
默认,public,final,abstract
自己定义:public居多
(2)成员变量:
四种权限修饰符均可,final,static
自己定义:private居多
(3)构造方法:
四种权限修饰符均可,其他不可
自己定义:public 居多
(4)成员方法:
四种权限修饰符均可,fianl,static,abstract
自己定义:public居多
6.成员变量和局部变量的区别
(1)书写位置不同
成员变量:在类中,方法外定义的变量。
局部变量:在方法声明上或者是方法定义中。
(2)内存中的位置不同
成员变量:在堆内存中。
局部变量:在栈内存中。
(3)生命周期不同
局部变量:随着方法调用而存在,随着方法调用完毕而消失。
成员变量:随着对象的创建完毕而存在,随着对象被GC回收掉而消失。
对象的回收:并不是立即回收,而是等待垃圾回收器空闲时回收掉。
(4)初始化不同
成员变量:可以不进行初始化,因为它在堆内存中(跟对象有关系),存在系统默认初始化。
局部变量:必须在使用之前对象局部变量进行初始化,否则报错。
7.静态变量与成员变量的区别
(1)所属不同
静态变量属于类,所以也称为为类变量 。
成员变量属于对象,所以也称为实例变量(对象变量) 。
(2)内存中位置不同
静态变量存储于方法区的静态区 。
成员变量存储于堆内存 。
(3)内存出现时间不同
静态变量随着类的加载而加载,随着类的消失而消失 。
成员变量随着对象的创建而存在,随着对象的消失而消失 。
(4)调用不同
静态变量可以通过类名调用,也可以通过对象调用。
成员变量只能通过对象名调用。
8.代码块
(1)定义:使用{}包起来的内容,就称为代码块。
(2)分类:
1)局部代码块:在方法中定义的{}。
作用:限定变量的生命周期,及早释放,提高内存利用率。
2)构造代码块:在类中的成员位置定义{}。
特点:每次执行构造方法之前先执行构造代码块。
作用:多个构造方法中相同的代码存放到一起执行。
3)静态代码块:在{}的前面加上static
作用:用于给类初始化。
特点:静态代码块随着的类的加载而加载,由于类加载一次,静态代码块执行一次。
(3)优先级:静态代码块 > 构造代码块 >构造方法
9.成员方法的分类
是否有返回值:有具体返回值类型的方法和没有具体返回值类型的方法。
是否有形参:有形参的方法和没有形参的方法。
10.构造方法
(1)特点:
1)方法名和类名相同
2)没有具体的返回值类型
3)连void都没有
(2)格式:
无参构造方法:
权限修饰符 方法名和类名相同(){
}
有参构造方法:
权限修饰符 方法名和类名相同(参数列表){
为成员变量赋值…
}
(3)作用:给对象的成员变量进行数据初始化。
(4)构造方法的重载:无参构造方法,有参构造方法。
(5)注意事项:
1)在写一个类的时候,如果没有提供无参构造方法,系统默认提供无参构造方法。
2)如果开发者提供有参构造方法,系统不会提供无参构造方法了,需要开发者给出无参构造方法。
11.对象的初始化过程
假设创建一个学生类对象Student s = new Student();
在内存中的创建过程:
(1)加载Student.class文件进内存 。
(2)在栈内存中为引用s开辟空间 。
(3)在堆内存中为学生对象开辟空间 。
(4)对学生对象的成员变量进行默认初始化 。
(5)对学生对象的成员变量进行显示初始化 。
(6)通过构造方法对学生对象的成员变量赋值 。
(7)学生对象初始化完毕,把对象地址赋值给s变量。
二、面向对象中的关键字
1.this
(1)定义:代表当前类对象的地址值引用。
(2)使用:
this.成员变量;访问当前对象的成员变量
this.成员方法名() ;访问当前对象的成员方法
this() :访问的是本类无参构造方法
this(xxx):访问的本类的有参构造方法
2.super
(1)定义:代表父类存储空间的标识(可以理解为父类引用)
(2)使用:
super.成员变量;访问的父类的成员变量
super.成员方法名() ;访问的是父类的成员方法
super():访问的是父类的无参构造方法
super(xxx):访问的父类的有参构造方法
3.this和super的区别
this:代表当前类的对象地址值引用
super:代表父类的空间标识(父类对象的地址值引用)
this调用成员或构造方法,访问的都是当前类的成员或构造方法。
super调用成员或构造方法,访问的都是父类的成员或构造方法。
4.private
(1)概念:私有的。
(2)作用:它可以修饰成员变量,也可以修饰成员方法。
(3)应用:是实现封装的基础。
(4)特点:被private修饰的成员只能在本类中访问,外界不能访问。只能通过提供的公共访问方法进行访问。
5.static
(1)概念: 静态的
(2)修饰属性:类.属性–所有对象都共享的
1)生命周期:
创建:类加载时,会把类里所有的静态属性都放在静态常量区中。
销毁:整个项目结束时,才会被销毁。
2)注意:此属性用类名直接调用
3)应用场景:static + final
(3)修饰方法:类.方法------直接用类名调用
应用场景:工具类
(4)静态代码块
6.static关键字的特点
(1)被static修饰的成员,随着类的加载而加载,且只加载一次。
(2)优先于对象存在:对象的创建是在类加载的后面。
(3)被static修饰的方法或者变量可以被该类的所有对象共享。
(4)被static修饰的变量以及方法可以被类名直接访问,也可以通过对象名来访问。
7.static的注意事项
(1)static关键字修饰的方法中没有this关键字。
(2)关于访问的问题:
非静态的成员方法,既可以访问静态的成员,也可以访问非静态的成员;
静态的方法只能静态的成员。
8.final
(1)定义:表示最终的,终态的,无法更改的。
(2)作用:
修饰类:该类不能被继承。
修饰变量:这个变量会成为一个常量(自定义常量),且只能被赋值一次。
修饰方法:该方法不能被重写。
(3)final修饰基本类型变量和引用类型变量的区别
基本数据类型:它的数据值不能再改变。
引用数据类型:它的地址值不能再改变,但它的成员变量值是可以改变的。
9.abstract
(1)概念:抽象的意思
(2)作用:
修饰类:抽象类
修饰方法:抽象方法
10.不能与abstract共存的关键字
(1)不能和final一块使用
final修饰成员方法:方法不能被重写。
abstract修饰的方法:子类必须重写。
(2)不能和private一块使用
private私有化,只能在本类中访问。
(3)不能和static一块使用
被static修饰的方法直接使用类名调用。
但是抽象方法又需要让子类重写,静态方法算不上方法重写。
11.访问权限修饰符
权限修饰符分类及定义
private:私有的
默认修饰符:不加入任何修饰符
protected:受保护的
public:公共的,访问权限最大
修饰符 | 本类 | 同包子类/同包无关类 | 不同包子类 | 不同包无关类 |
---|---|---|---|---|
private | Y | N | N | N |
默认修饰符 | Y | Y | N | N |
protected | Y | Y | Y | N |
public | Y | Y | Y | Y |
三、面向对象的三大特征——封装
概念:将一个类的某些成员私有化,使外界不能够直接访问,只能通过一些公共的方法间接的访问。
优点:
隐藏具体的实现细节,提供公共的访问方式;
提高了代码的复用性;
提高安全性。
原则:将不需要对外提供的内容都隐藏起来。
四、面向对象的三大特征——继承
1.继承
(1)概念:将一些类似的类的共性内容抽取出来,定义在单独的一个类中,他们和这个类产生的关系。
(2)实质体现:一种"is a"的关系,即A类是B类的一种或者B类是A类的一种。
(3)语法:class 子类 extends 父类{}
(4)名词解释:父类:被继承的类,也成基类或者超类。
子类:继承的类,也称派生类。
(5)应用:产生继承关系后,子类可以使用父类的属性和方法,也可定义子类独有的属性和方法。
(6)好处:提高了代码的复用性和可扩展性,是多态的前提条件。
(7)特点:java的继承为单继承,一个类只能有一个直接父类,但可以有多级继承。
2.继承中访问子父类成员的特点
(1)访问成员变量
1)子类中和父类中成员变量名称不同:分别访问即可。
2)子类中和父类中成员变量名称相同:遵循"就近原则"。
从子类局部位置到成员位置,再到父类成员位置。如果找到就使用,找不到就逐级向上查找;如果直到父类成员位置都没找到,就报错。
(2)继承中访问成员方法
1)成员方法名称不同:分别访问即可。
2)成员方法名称相同:先在子类中找是否存在这个方法,如果子类找不到这个方法,就在父类中找,如果父类中都找不到,就报错。
(3)继承中访问构造方法
1)可以通过super间接访问父类的构造方法。
2)子类的所有构造方法默认访问父类的无参构造方法。
3)访问父类无参构造的原因:为子类对象初始化父类数据。
3.分层初始化
由于存在继承关系,创建子类对象时,先要执行父类构造,进行父类属性的初 始化,在执行子类构造,进行初始化。
4.继承中的注意事项
(1)不能继承父类的私有的成员(成员变量,成员方法)。
(2)不能够继承父类的构造方法,但可以通过super关键字,来间接访问。
(3)子父类不在同一个package中时,default修饰的属性和方法,子类无法访问。
(4)子类的构造方法中第一句话默认存在”super();”可以不写。
(5)子父类在内存中的加载顺序:先加载父类,再加载子类。
(6)当类中只有无参构造,可以不写,系统会自动提供。
(7)当类中有有参构造,系统不提供无参构造,需要开发者自行编辑。
(8)当父类中有有参构造,却没有无参构造,程序会报错;需要手动为父类添加无参构造,或者让子类构造都调用父类的有参构造。
5.方法重写
(1)概念:子类中出现了和父类中一模一样的方法。
(2)场景:当父类提供的方法无法满足子类需求时,可以在子类中定义和父类相同的方法进行重写。
(3)原则:方法名、参数列表、返回值类型都必须与父类的相同,访问修饰符不能比父类更严格。
(4)注意:子类重写父类方法后,调用时优先执行子类重写后的方法。
6.重载(Overload) 和重写(Override)的区别
(1)方法重写存在于具有继承关系的子类中。
(2)方法的重载存在于一个类中。
(3)方法重写:方法名、参数列表、返回值类型都必须与父类的相同,访问修饰符不能比父类更严格。
(4)方法重载:方法名相同、参数列表不同、与访问修饰符和返回值类型无关。
五、面向对象的三大特征——多态
1.多态
(1)定义:一个事物在不同时刻表现出的不同状态。
举例:
水:固态,液体,气态
动物类: 猫/狗都是动物
(2)前提条件
1)必须存在继承关系。
2)要有方法重写
3)需要存在:父类引用指向子类对象
2.多态的成员访问特点
父类名 对象名 = new 子类名() ;
(1)成员变量:编译看左,运行看左边。
(2)成员方法:编译看左边,运行看右(因为存在方法重写)。
(3)静态的成员方法:编译看左,运行看左。
子类出现了和父类一摸一样的静态方法,静态方法跟类相关,不存在重写。
访问方式:类名.方法名();
(4)构造方法:分层初始化
3.多态的优缺点
(1)优点:
1)提高了代码的扩展性(由多态)
2)提高了代码的复用性,维护性(由继承关系保证)
(2)弊端:不能够访问子类的特有功能。
解决方法:
方式1:创建子类具体类对象:
子类名 对象名 = new 子类名() ;
对象名.访问子类自己的功能;
从内存角度考虑,在堆内存中产生一个内存空间,比较消耗 内存空间。
方式2:向上转型
Fu f = new Zi() ;
向下转型
Zi z = (Zi)f;
不需要重新new对象,堆内存中节省内存空间。
4.多态中的转型
(1)前提条件:要使用向下转型,必须先使用向上转型。
(2)向上转型:父类引用指向子类对象
格式:父类名 引用名=new 子类名();
(3)向下转型:将父类的引用强制转换为子类的引用。
格式:子类名 引用名 = (子类名)父类引用;
(4)注意事项:多态中向下转型使用不当,程序出现异常。
ClassCastException:运行时期异常(RuntimeException)的一种
出现原因:使用向下转型的时候类型不匹配导致的。
规避该异常:向下转型前,应该判段引用中的对象真实类型,保证类型转换的正确性。
使用instanceof关键字:
if(父类引用 instanceof 类型){
}
六、面向对象中的引用类型
1.抽象类
(1)定义:在一个类中,将某个功能只给出一个声明(抽象方法),那么该类定义为抽象类。
(2)抽象类格式:权限修饰符 abstract class 类名{}
(3)抽象方法:没有方法体的方法
格式:权限修饰符(public) abstract 返回值类型 方法名() ;
(4)抽象类多态:父类引用指向子类对象
格式:父类名 对象名 =new 子类名() ;
(5)本质:强制子类必须完成的事情。
2.抽象类的成员特点
(1)成员变量:既可以定义常量,也可以定义变量。
(2)成员方法:即可定义抽象方法,也可以定义非抽象方法。
(3)构造方法:对父类中的数据进行初始化,不能创建对象。
3.抽象类的注意事项
(1)抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类。
(2)抽象类中不一定全是抽象方法,也可以有非抽象方法。
(3)抽象类不能直接实例化,需通过具体的子类进行实例化。
(4)继承抽象类的子类必须重写父类所有抽象方法,否则该类必须声明为抽象类。
(5)抽象类的子类:
子类是具体类,直接以抽象类多态的形式实例化。
子类是抽象类,应该还要提供更最具体的子类,否则都无法实例化。
(6)在抽象类中定义抽象方法的时候,必须使用abstract修饰符不能省略。
(7)定义抽象方法时只能使用public /protected权限修饰符修饰。
(8)抽象类多态的访问成员特点与具体类多态访问特点相同。
(9)将一个类定义为抽象类的意义在于,让其不能直接实例化。
4.接口
(1)概念:是一种能力和约定。
(2)格式:
interface 接口名{
…
}
(3)应用:当父类的方法种类无法满足子类需求时,可以实现接口扩充子类能力。
(4)接口实例化
接口多态:接口不能直接实例化 ,需要通过接口引用指向实现类对象。
格式:接口名 对象名 =new 子实现类名() ;
(5)开发中接口的命名格式
命名格式:
接口名:XXXDao
接口子实现类:接口名的后面+Impl
举例:
用户接口
UserDao:(dao---->Data Access Object :数据访问对象)
用户接口实现类
class UserDaoImpl implements UserDao{
....
}
5.注意事项
(1)接口中的方法只能是抽象方法,不能有方法体。
(2)接口的命名规则:多个单词,遵循"大驼峰命名法"。
(3)类实现接口时,必须实现接口中所有抽象方法,否则此类为抽象类。
(4)实现接口中的抽象方法时,访问修饰符必须是public。
(5)接口多态的访问成员特点与具体类多态访问特点相同。
6.接口的成员特点
(1)属性: 只能是常量,默认被public static final修饰(可以省略不写)。
(2)成员方法:只能是抽象方法,默认被public abstract修饰(可以不写)。
(3)构造方法:接口没有构造方法
7.接口的优点
(1)降低程序的耦合度;
(2)更自然的使用多态;
(3)设计与实现完全分离;
(4)更容易搭建程序框架;
(5)更容易更换具体实现。
8.类、接口的关系
(1)类与类之间:继承关系,只支持单继承,不支持多继承,但是可以多层继承。
(2)类与接口之间:实现关系,一个类在继承另一个类的同时,可以实现多个接口。
(3)接口与接口之间:继承关系,可以单继承,也可以多继承。
9.抽象类和接口的区别
(1)成员的区别
抽象类:
属性:既可以定义常量,也可以变量。
成员方法:既可以是抽象方法,也可以是非抽象方法。
构造方法:存在无参构造/有参构造,对数据进行初始化。
接口:
属性:只能是常量。
成员方法:只能是抽象方法
构造方法:不存在构造方法
(2)关系的区别:
类与类之间:单继承,不支持多继承,但是可以多层继承。
类与接口:实现关系,一个类继承另一个类的同时,可以实现多个接口。
接口与接口:继承关系:extends,可以单继承,也可以多继承。
(3)设计理念的区别
抽象类:由继承来保证代码的复用性,由多态来保证代码的扩展性。体现一种"is a"的关系。
接口:是一种额外的功能,体现的是一种"like a"的关系。
10.内部类
(1)概念:在A类中定义一个B类,就将B类称为A类的内部类;将A类称为B类外部类。
(2)内部类的分类:
1)成员内部类:在类的成员位置定义的类。
2)局部内部类:在局部位置中定义的类。
(3)注意事项:
1)外部类和内部类之间是没有继承关系的。
2)当内部类与外部类的变量名相同时,可以使用外部类的this调用外部类变量:外部类名.this.变量。
11.内部类的成员访问特点
(1)成员内部类的成员访问特点:
1)内部类的成员可以直接访问外部类的成员包括私有。
2)外部类的成员向访问成员内部类的成员的时候,不能直接访问,要通过内部类对象访问。
3)访问外部类中的成员内部类的成员方法,访问方式:
1)前提条件:就是当前成员内部类是非静态的。
2)固定格式:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
举例:Outer3.Inner3 oi = new Outer3().new Inner3() ;
(2)静态成员内部类访问特点:
1)将静态的成员内部类看成是外部类的静态成员。
2)静态的成员内部类的成员方法,只能访问外部类的静态成员。
3)访问外部类的静态成员内部类的成员方法,访问方式:
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
4)访问外部类的静态成员内部类的静态成员方法,访问方式:
外部类民名.内部类名.静态成员方法名();
(3)局部内部类的成员访问特点:
1)局部内部类的成员方法可以直接访问外部类的成员,包括私有的。
2)外部类访问局部内部类:在当前外部类的成员方法中,创建内部类对象调用它的方法。
3)局部内部类访问外部类的局部变量:
Jdk7之前(包括jdk7)需要开发者手动使用final修饰局部变量。
原因:
局部变量的生命周期:随着方法调用而存在,随着方法调用完毕而消失。
由于当前局部内部类中的成员方法还在使用局部变量,间接通过在外部类的成员方法中创建内部类对象。
调用内部类的成员方法,访问局部变量,对象不会立即被回收,需要等待GC空闲时候回收。
内部类的成员方法还在访问,需要将当前局部变量定义为常量,存储在静态区中。
Jdk8开始默认存在,不用添加final。
12.匿名内部类
(1)概念:它是内部类的一种简化格式,没有具体类名
(2)格式:
new 类名(抽象类类名)/接口名(){
重写方法…
};
举例:
new Person(){ //Person:抽象类
//重写方法
public void love() {
...
}
} ;
(3)本质:就是一个继承该抽象类或者实现了该接口的子类匿名对象。
13.匿名对象
(1)概念:没有名字的对象。
(2)格式: new 类名();
(3)特点:
1)可以作为形式参数传递。
2)一个匿名对象只能使用一次。
3)匿名对象创建完毕,使用完毕就立即被回收(节省内存空间)
(4)应用场景:移动端(android)大量去使用匿名对象或者匿名内部类。
14.方法的形参是引用类型
(1)具体类:需要传递该具体类的对象。
(2)抽象类:实际参数需要该抽象类的子类对象。
(3)接口:实际参数需要该接口子实现类对象。
15.方法有具体返回值类型
(1)基本数据类型:四类八种,需要返回该基本类型的数据值。
(2)引用数据类型:数组,类,接口
具体类:需要返回(return)该具体类的对象。
抽象类:需要返回该抽象类的子类对象。
接口:需要返回该接口的子实现类对象。
七、提及的知识
1.Java中的开发原则
(1)原则:低耦合,高内聚
(2)耦合:类与类之间的关系,越少越好。在开发中尽可能降低程序间的耦合度。
(3)内聚:完成某个事情,在一个类中能完成的,尽量一个类中完成。
2.选择排序
(1)思想:使用数组中0角标对应的元素依次和后面元素进行比较,小的值往前放,第一次比较完毕,最小值出现在最小索引处,依次这样比较。
(2)规律:比较的次数:数组长度-1次
(3)代码实现:
for(int x = 0 ; x < arr.length-1 ;x ++) {//x=0,1,2,3
for(int y = x +1 ; y < arr.length ; y ++) {
if(arr[y] < arr[x]) {
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
}
3.eclipse中的常用快捷键
快捷键 | 作用 |
---|---|
alt+/ | 代码提示 |
cltr+shift+/ | 将多行代码注释掉 |
cltr+shift+| 取消多行注释 | |
ctlr+/ | 单行注释/取消单行注释 |
alt+sift+s–>c | 创建无参构造方法 |
alt+shift+s–>o | 创建有参构造方法 |
alt+shift+s–>r | 提供setXXX(Xx xx)/getXXX |
ctlr+d | 删除某一行代码 |
ctrl+shift+o | 导包的快捷键 |
ctrl+1/ctlr+2+l(字母) | 创建对象的时候使用,自动补全代码 |
alt+shift+s—h | 重写toString()方法 |
4.文档说明书的制作
(1)定义工具类
(2)无参构造方法私有化,外界不能创建该类对象,里面所有的功能全都是static的 。
(3)在工具类中,对所有的功能加入文档注释。
(4)针对工具类文件产生一个文档说明
打开dos--->进入到工具类所在目录中
javadoc -d 目录名 -author -version 工具类名.java
5.包
(1)概念:文件夹(目录)
(2)包的命名规则:公司域名反写,中间.或者_隔开,字母全部小写。
单级包:com
多级包:com.xxxxx.user
(3)注意:以后在开发中,通过包来划分结构
按照模块划分
用户模块:针对用户的增删查改
com.xxxx.user
订单模块:com.xxxx.order
按照功能划分
用户的添加功能:com.xxxx.user.add
修改功能:com.xxxx.user.update
6.带包的类的编译运行过程
同一个包下:
(1)手动方式
1)编译当前文件:javac 类名.java
2)手动建立包对应的文件夹。
3)把编译产生的class文件放到建立的文件夹中。
4)带包名运行字节码文件:java 包名.类名
(2)自动方式
1)加入-d编译:javac -d . 类名.java
2)带包名运行字节码文件:java 包名.类名
不同包下:
(1)先编译被导入的类
javac -d . 导入类的类名.java
(2)编译当前类
javac -d . 当前类的类名.java
(3)运行当前类
java 当前类的包名.当前类的类名
注意:
导包:不同包下的类之间的访问,需要导包。
格式:import 包名;
优先级:pakcage>import>class
总结
本文主要从面向对象的基础、面向对象中的关键字、面向对象中的引用类型、面向对象的三大特征——封装、继承和多态等方面总结了JavaSE面向对象部分的知识点。