复习
一:面向对象
不关注实现的过程,只关注结果
1. 三大特征:封装,继承,多态
1.1.封装
隐藏对象的属性和实现细节(方法等),仅提供对外访问方式(属性:get/set,方法:先本类调用)
1.2.继承
从已有的类中派生出新的类,新类能吸收已有类的数据属性与行为,并可以扩展新能力
1.3.多态
指的是同一实体同时具有多种形式,即同一对象在不同时刻,代表的对象不一样,指的是对象的多种形态
2. 类和对象
2.1.类(class)
1: java最基本的语言就是类
2: 类是一类事物抽取共同属性与功能形成的
3: 可以理解为模板或者图纸
注意: 类在现实世界并不存在,是一种对象的数据类型
2.2.对象(new)
1:特点:对象的属性,功能,标识
属性:用来描述对象的剧本特征
功能:描述对象可以完成的操作
标识:每个对象在内存中都有唯一一个地址值用来区分
2.3.类和对象的关系
1.我们先创建类,再通过类创建对象
2.一个类可以创建多个对象
3.类是抽象的,对象是具体的
2.4:对象在内存中的存储
1.局部变量存在栈中,方法执行完毕就被释放
2.对象存在堆中,对象不在被使用时,内存释放
3.每个堆内存的元素都有地址值
4.对象中的属性都是成员变量,存在默认值
2.5:对象创建过程
1.首先在栈内存中开辟空间存放引用类型
2.其次在堆内存中开辟空间存放对象
3.给对象初始化(属性给赋值)
4.生成唯一地址值交给引用类型
5.通过应用类型调用对象
3. 封装(private)
3.1.定义
隐藏对象的属性和实现细节(方法等),仅提供对外访问方式(属性:get/set,方法:先本类调用)
3.2.优点
提高安全性,提高重用性
3.3.private
修饰成员变量和成员方法,被私有化的成员和方法只能在本类中直接调用
3.4.protected
protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private
3.5.如何访问私有资源
1.封装的成员变量的使用
1:setXxx-对外提供设置值得方式
2:getXxx-对外提供获取值的方式
2.封装的成员方法的使用
1.把私有方法放在公共方法中供外界调用
4.匿名对象
4.1:Person p =new Person();
p-对象的名字
p.eat();调用方法
4.2new Person().eat();匿名对象
5.构造方法
5.1.概念
1.与类名相同且没有返回值的方法
2.功能:完成对象的创建或初始化
3.当类创建对象(实例化)时,就会自动调用构造方法
4.构造方法与普通方法一样也可以重载
5.2.形式
与类名相同,且没有返回值类型,可以含参也可以不含餐
修饰符 方法名([参数列表]){
方法体
}
5.3.记忆
特点:方法名与类名相同,且没有返回值类型
执行时机:创建对象及执行
默认会创建无参构造,但是如果定义含参构造,默认的无参构造会被覆盖,需要手动添加
6.构造代码块与局部代码块
顺序:构造代码块–>构造方法–>普通方法–>局部代码块
6.1.形式
{代码…}
6.2.构造代码块特点
1.位置:类里方法外
2.作用:用于抽取构造方法中的共性代码
3.执行时机:每次调用构造方法前都会先调用构造代码块
4.注意: 构造代码块优先于构造方法加载
6.3.局部代码块
1.位置:在方法里面的代码块
2.作用:通常用于控制变量的作用范围
3.注意:变量的作用范围越小越好,成员变量会存在线程安全问题
7.This与Super
6.1.this
代表本类对象的一个引用对象
6.2.形式
this.name=name//this.name–>代表成员变量;;;name—>代表局部变量
6.3.作用
1.当成员变量与局部变量同名时,可以使用this指定本类的成员变量
2.用于调用构造方法.含参构造中调用无参或者无参函数调用含参函数,用于第一行
6.4.super
可以看作是父类的对象 Father super =new Father();
1.当父类的成员变量与子类同名时,可以使用super关键字指定父亲的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super()–调用无参构造
super(参数)—调用的是父类对应参数的构造方法
注意:在构造方法里,出现的调用位置必须是第一行
6.5.二者区别
1.this代表本类对象的引用
super代表父类存储空间的标识,可以理解成父类对象的引用
使用this关键字或者super关键字调用构造方法时都必须放在第一行
8.继承(extends)
8.1.定义
从已有的类中派生出新的类,新类能吸收已有类的数据属性与行为,并可以扩展新能力
8.2.理解
新定义的类可以增加新的数据或新的功能,也可以使用父类的功能,但不能选择性继承
8.3.特点
1.使用extends关键字来表示继承
2.相当于子类把父类的功能复制一遍
3.java只支持单继承
4.继承可以传递
5.父类的私有成员由于有私有访问限制,所以子类不能使用父类私有资源
6.继承多用于功能修改,子类拥有父类功能的同时,进行功能拓展
7.像是is a关系
9.重写(Overrid)
9.1.重写原因
子类方法中的签名与父类完全一致时,会发生覆盖/复写情况
9.2.重写要求(两同,两小,一大)
两同: 方法名 参数列表要完全一致
两小: 子类的返回值类型小于等于父亲的返回值类型,子类抛出的异常小于父类方法抛出的异常
一大: 子类方法的修饰符权限要大于等于父类被重写的方法的修饰符权限
9.3.优点与缺点
1.优点
提高了代码的复用性
提高了代码的维护性
2.缺点
继承让类和类建立了关系,类的耦合性加强
当父类发生变换时,子类也不得不跟着发生变化,削弱了子类的独立性
10.static
10.1.定义
关键字,用于修饰成员变量和成员方法
10.2.特点
1.static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类加载而加载,最先加载,优先于对象进行加载
4.静态资源可以通过类名直接调用,也被称做类资源
5.静态资源被全局所有对象所共享,值只有一份
(不管使用哪种方式修改静态变量的值,使用任何方式查看都是静态变量刚刚修改了的值)
6.静态资源只能调用静态资源
7.静态区域内不允许使用this和super关键字
10.3.静态代码块
1.形式
static{}
2.特点
1.静态资源随着类的加载而加载,并且只被加载一次,一般用于项目的初始化
2.被static修饰,位于类里方法外
3.静态代码块,构造代码块,局部代码块的比较
静态代码块:在类加载时就加载,并且只被加载一次,一般用于项目初始化
构造代码块:在创建对象时会自动调用,每次创建对象都会被调用,提取构造共性
局部代码块:方法里的代码块,限制局部变量的范围
4.执行顺序
静态代码块–>构造代码块–>构造方法–>普通方法–>局部代码块
11.final
11.1.定义
1.java的一个关键字
2.最终的意思
3.final可以修饰类,方法,属性
初衷:java继承出现以后,子类可以更改父类的功能.当父类功能不愿一子类改变时,可以利用final关键字修饰父类
11.2.特点
1.被final修饰的类,不能被继承
2.被final修饰的方法,不能被重写
3.被final修饰的字段是个常量,值不可以被修改
(注意:不管是成员位置还是局部位置,常量定义的时候必须赋值)
(注意:常量名必须全是大写,单词与单词之间使用_分割)
4.常量的定义形式: final 数据类型 常量名 = 值
12.多态
12.1.定义
指的是同一实体同时具有多种形式,即同一对象在不同时刻,代表的对象不一样,指的是对象的多种形态
12.2.特点
1.多态的前提是继承和方法的重写
2.父类引用指向子类的对象如:Animal a=new Cat();
(创建出子类对象的值,交给父类类型的引用类型变量来保存)
3.多态中,编译看作左边,运行看右边
(必须要在父类中定义这个方法,才能通过编译,把多态对象看作是父类类型
必须要在子类重写这个方法,才能满足多态,实际干活的是子类(父类的定义,子类的方法体))
12.3.优点
1.多态可以让我们不用关心某个对象导体具体是什么类型,就可以使用该对象的某些方法
2.提高了程序的可扩展性和可维护性
12.4.使用
1.多态对象把自己看作是父类类型
2.使用父类的成员方法
3.成员方法:由于存在重写现象,所以使用的是子类的
4.静态成员:随着类的加载而加载,谁调用就返回谁的
5.只要创建一个方法,就可以执行截然不同给的效果
忽略子类对象的差异统一看作父类类型
public static void main(String[] args) {
Fruit f = new Fruit();
Fruit a = new Apple();
Fruit o = new Orange();
get(f);
get(a);
get(o);
}
public static void get(Fruit f){
f.clean();
}
}
12.5.静态变量和实例变量的区别
1.静态变量:(类变量,加static关键字)
|-随着类的加载而加载；
|-优先于对象加载；
|-被所有对象所共享；
|-可以直接被类名调用；
2.实例变量:无static修饰，称为实例变量
12.6.向上转型与向下转型
1.向上转型
1.定义(类似于多态)
可以把不同的子类对象都当做父类来看,进而屏蔽不同子类对象之间的差异,统一调用标准
Parent p =new Child();
2.说明
向上转型时,子类对象当成父类对象只能调用父类的功能,如果子类重写了父类中声明过的方法,方法体执行的就是子类重写过后的功能,但此时对象把自己看作是父类类型,所以其他资源还是使用父类的
2.向下转型
1.定义
子类的引用指向子类对象,过程中必须采取强制转换.这个是之前向上转型过的子类仍然想执行子类特有的功能,所以需要重新恢复子类
Parent p =new Child();//向上转型,此时p时parent类型
Child c =(Child)p; //此时,把Parent类型的p转换成小类型Child;
2.说明
相当于创建了一个子类对象一样,可以用父类的,也可以用自己的
向下转型,是为了方便使用子类的特殊方法,也就是说当子类类方法做了拓展功能,就可以直接使用子类功能
13.异常
13.1.定义
1.异常是用来封装错误信息的对象
2.由异常类型,提示信息,报错行号提示三部分组成
13.2.异常的继承结构
Throwable:顶级父类
—Error :错误,程序无法处理
—Exception: 我们可以编码修复的错误
13.3.异常的处理方式
1.捕获
try{
需要捕获得代码
}catch(异常类型 异常名){
处理方案
}
2.抛出
在方法上设置异常抛出管道
void method throws Exception1,Exception2{}
14.抽象类(abstract)
14.1.定义
1.抽象方法:被abstract关键字修饰且只有声明没有方法体的方法
例如:public abstract void eat();
2.抽象类: 被abstract关键字修饰的类叫抽象类
3.如果一个类含有抽象方法,那么他一定是抽象类
4.抽象类的方法实现交给子类来完成
14.2.格式
权限修饰符 abstract 返回值类型 方法名(参数列表);
14.3.特点
1.abstract可以修饰方法或者类
2.被abstract关键字修饰的类叫抽象类,被abstract关键字修饰的方法叫做抽象方法
3.抽象类中可以没有抽象方法
4.如果类中有抽象方法,那么该类必须定义为抽象类
5.子类继承抽象类以后,要么子类还是抽象类,要么就把父类所有的抽象方法都重写
6.多用于多态中
7.抽象类不可以被实例化
14.4.抽象类构造函数
1.抽象类存在构造方法:不是为了自己使用,而是为了子类创建对象使用super();
14.5.抽象类中成员测试
1.如果一类中都是普通方法,修饰成抽象类的作用是因为抽象类不可以被实例化,
所以如果不想让外界创建本类的对象,就可以把类修饰成抽象类
14.6.总结:abstract注意事项
1.抽象方法要求子类继承后必须重写。
那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1.private：被私有化后，子类无法重写，与abstract相违背。
2.static：静态优先于对象存在，存在加载顺序问题。
3.final：被final修饰后，无法重写，与abstract相违背
15.接口
15.1.定义
接口在java中也是一种抽象类型,接口中的内容是抽象形成的需要实现的功能,更像是一种规则和一套标准
15.2.格式
interface 接口名{代码}
15.3.特点
1.通过interfance关键字类定义接口
2.通过implements让子类来实现接口
3.接口中的方法全都是抽象方法
4.可以把接口理解为一个特殊的抽象类(接口不是类)
5.类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
6.接口突破了java单继承的局限性
7.接口和类之间可以多实现,接口和接口之间可以多继承
8.接口是对外暴露的规则,是一套开发规范
9.接口提高了程序的拓展功能,降低了耦合性
10.接口中的是静态常量，实际上的写法是public static final int age = 20;只不过接口中可以省略不写，会默认拼接，所以写成 int age = 20
16.总结
16.1.类与类的关系
1.继承关系,只支持单继承
2.子类如果要修改原有功能,需要重写(方法名与父类一致+权限修饰符>=父类修饰符)
16.2.类与接口的关系
1.实现关系(implement),可以单实现,也可以多实现
2.class A implement B,C{}
其中A是实现类,B和C 是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类
16.3. 接口与接口的关系
1.是继承关系,可以单继承,也可以多继承
2.interface A extends B,C{}
其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
3.class X implements A{}
X实现类需要重写ABC接口的所有方法,否则就是抽象类
4.class A extends B implements C,D{}
其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
这时A需要重写CD接口里的所有抽象方法
16.4.接口与抽象类的区别
1.接口是一种用interface关键字定义的类型
2.抽象类是一种用class关键字定义的类型
3.接口中的方法都是抽象方法,还有默认方法与静态方法
4.抽象类中的方法不做限制(可以存在普通方法,也可以存在抽象方法)
5.接口中的常量都是静态常量
6.抽象类中可以写普通的成员变量
7.接口没有构造方法，不可实例化
8.抽象类有构造方法，但是也不可以实例化
9.接口是先天设计的结果，抽象是后天重构的结果
10.接口可以多继承 抽象类只能单继承
1016
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
