面向对象
设计原则:
1:将公共的属性和行为封装到父类中
2:所有子类的行为都一样------普通方法
所有子类的行为不一样------抽象方法
3:若符合既是也是原则时,使用接口
1.什么是类?什么是对象
1)现实世界是由很多对象组成的
基于对象抽出了类
2)对象:真实存在的单个的个体
类:类型/类别,一类个体
3) 类中可以包含:
3.1)所有对象所共有的特征/属性(静)--变量
3.2)所有对象所共有的行为(动)----方法
4)一个类可以创建多个对象
同一个类的多个对象,结构相同,数据不同
5)类是对象的模板,对象是类的具体的实例
2 null:空,没有指向任何对象
不能对null做任何操作,若操作就会报空指针异常
0. 方法的签名:方法名+参数列表
1.方法的重载(Overload)
1)同一个类中,方法名称相同,参数列表不同
2)编译期在编译时自动根据方法的签名来绑定不同,调用不同的方法
2.构造方法(构造器、构建器、构造函数):
1)常常用于给成员变量赋初始值
2)与类同名,没有返回类型
3)在创建(new)对象,自动调用
4)若自己不懈构造方法,则编译期默认提供无参构造
若自己写了构造,则补再默认提供
5)构造方法可以重载
3. this:指代当前对象,哪个对象调指的就是哪个对象
方法中访问成员变量之前默认都有个this
this的用法:
1)this.成员变量名------ 访问成员变量
2)this.方法名()--------调用方法
3)this()----------调用构造方法
4.引用类型数组:
1.内存管理:有jvm来管理
1)堆:
1.1)用于存储所有new出来的对象(包括成员变量)
1.2)成员变量的生命周期:
创建(new)对象时存在堆中,对象被gc回收时一并消失
1.3)垃圾:没有任何引用所致想的对象
垃圾会输器(gc)不定时到堆中查看,
回收过程是透明的,并不是一看到垃圾就马上回收
若想快点回收可以调用System.gc()
1.4)内存泄漏:不再使用的对象没有被及时的回收
建议:当对象不再使用时,及时将引用设置为 null
2)栈:
2.1)用于存储正在调用中方法的所有局部变量()
2.2)调用方法时在栈中为该方法分配一块对应的栈桢
栈桢中所包含所有的局部变量(包括参数),
方法调用结束时,栈桢消失,局部变量一并消失
2.3)局部变量的生命周期:
调用方法时存在栈中,方法调用结束时与栈桢一并消失
3) 方法区:
3.1)用于存储.class字节码文件(包括方法)
3.2)方法只有一份
2 继承:
1)目的:避免代码重复,有利于代码的重用
2)通过extends实现继承
3)父类:所有子类所共有的属性和行为
子类:子类所特有的属性和行为
4)子类继承父类后,子类具有:子类+父类
5)一个父类可以有多个子类
一个子类只能有一个父类---单一继承
6)继承具有传递性
7)java规定:构造子类之前必须先构造父类
子类构造中若没有调用父类的构造,则默认super()来调用父类的无参构造
若自己调了,则不再默认提供
super()调用父类构造,必须文娱子类构造的第一句
3.super: 指代当前对象的父类对象
用法:
super.成员变量名----访问父类的成员变量
super.方法名()----调用父类的方法
super()--调用父类构造方法
4.向上造型:
1)父类型的引用指向子类的对象
2)能点出来什么,看引用的类型
1. 方法的重写(Override)
1)发生在父子类中,方法名相同,参数列表相同,方法体不同
2) 重写方法被调用时,看对象的类型
重写+重载的区别
1)重写:父子类中,方法名相同,参数列表相同,方法体不同
遵循“运行期”绑定,根据对象的类型调用方法
2)重载:一个类中,方法名相同,参数列表不同,方法体不同
遵循“编译期”绑定,根据引用的类型绑定方法
3.package:
1)作用:避免类的命名冲突
2)包名可以有层次结构
3)建议:包名所有字幕都小写
4)类的完全限定名:包名.类名
import:
1)作用:声明类/引入类
2)同包中的类可以直接访问
不同包中的类想访问:
2.1)先import声明类再访问类(建议)
2.2)类的全称----太繁琐(不建议)
4.访问控制修饰符:
1)public:公开的,任何类
2)private:私有的,本类
3)protected:受保护的,本类,子类,同包类
4)默认的:什么也不写,本类,同包类
类的访问修饰:public和默认的
类成员的访问修饰:如上4种都可以
5. static:静态的
1.成员变量:
1.1).实例变量:
1)属于对象的,存在堆中
2)有几个对象就有几个实例变量
3)必须通过 对象.来访问
2.1).静态变量:
1)属于类的,存在方法区中
2)只有一份
3)常常通过类名.来访问
2.静态方法
2.1)由static修饰
2.2)属于类的,存在方法区,中只有一份
2.3)常常通过类名.来访问
2.4)没有隐式的this
静态方法中不能直接访问实例成员
2.5)何时用:
方法的操作仅与参数有关,与对象无关的时候
3.静态块:
3.1)由static修饰
3.2)属于类的,类被加载期间自动执行
类只被加载一次,所以静态块也执行一次
3.3)何时用:常常用于加载静态资源(图片,音频,视频)
4.final: 不能变
1)修饰变量:变量不能被改写
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
final修饰成员变量,两种方式:
1)声明的同时初始化
2)构造方法中初始化
final 修饰局部变量,只要在用之前初始化即可
1.static final 常量:
1)必须声明同时初始化
2)通过类名点来访问,不能改变
3)建议:常量名所有字母都大写
4)在编译时被直接替换为具体的值,效率高
2.抽象方法:
1)由abstract修饰
2)只有方法的定义,没有方法的实现(大括号都没有)
3.抽象类
1)由abstract修饰
2)包含抽放方法的类必须是抽象类
3)抽象类不能被实例化
4)抽象类是需要被继承的,子类
4.1)重写所有抽象方法---常用
4.2)页声明为抽象类----不常用
5)抽象类的意思:
5.1)包含公共的属性和行为,被子类所共享---代码重用
5.2)为所有子类提供一种公共的类型--向上造型
5.3)包含抽象方法,为子类提供一个统一的入口
4. 接口:
1)是一个标准、规范
遵守了这个标准,就能干某件事
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的,实现类/子类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口,用逗号分隔
若又继承又实现是,应先继承extends后实现implements
7)接口可以继承接口
1. 多态:
1) 意义:
1.1) 同一类型的引用指向不同的对象时,有不同的实现;
-------行为的多态:cut(),run()
1.2) 同一对象被造型为不同类型时,有不同的功能;
---------对象的多态:我,水
2) 向上造型;
2.1) 父类型的引用指向子类的对象
2.2) 能造型成的类型有:
父类型、实现的接口
2.3) 能点出什么,看引用的类型
1.父类引用能指向子类对象,子类引用不能指向父类对象;
2.向上造型:父类引用指向子类对象,例如:Father f1 = new Son();
3.向下造型:把指向子类对象的父类引用赋给子类引用,需要强制转换,例如:
Father f1 = new Son();
Son s1 = (Son)f1;
但有运行出错的情况:
Father f2 = new Father();
Son s2 = (Son)f2;//编译无错但运行会出现错误
在不确定父类引用是否指向子类对象时,可以用instanceof来判断:
if(f3 instanceof Son){
Son s3 = (Son)f3;
}
3) 强制类型转换 成功的条件:
3.1)引用所指向的对象,就是该类型;
3.2)引用所指向的对象,实现了该接口;
4) 建议强转之前 通过instanceof 来判断引用是否是某种类型
instanceof 返回boolean
强转成功的条件就是它为true
2.内部类:
1)成员内部类:不太常用
1.1)类中套类,外面的叫外部类,里面的叫内部类
1.2)内部类通常只服务于外部类,对外不具备可见性
1.3)内部类对象通常是在外部类中创建
1.4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向创建他的外部类对象
语法:外部类名.this.
2)匿名内部类:比较常用
2.1) 如果想创建一个类的对象,并且对象只被创建一次。
此时该类不必命名,称为匿名内部类
2.2)匿名内部类中访问外部的数据,该数据必须是final的
swing 中的事件:
1.事件:发生了一件事
2.事件的处理:发生那个事之后所做的操作
3.侦听器:
1)先有个侦听器
2)把侦听器添加到面板上
package oo.day06;
//多态演示
public class CastTest {
public static void main(String[] args) {
/*
//向上造型
Aoo o1 = new Boo(); //向上造型
Inter1 o2 = new Boo(); //向上造型
//Inter1 o3 = new Coo(); //错误,类型不匹配
*/
/*
//向上造型时,点出来什么,看类型
Aoo o1 = new Boo(); //向上造型
o1.b(); //正确
//o1.num1=5; //编译错误,点出来什么看类型
*/
//强转时看对象
Aoo o1 = new Boo(); //向上造型
Boo o2 = (Boo)o1; //o1指向的对象是Boo
Inter1 o3 = (Inter1)o1;
//o1指向的对象实现了Inter1接口
//Coo o4 = (Coo)o1; //类型转换异常
//o1指向的对象与Coo无关
//instanceof为true两种情况:
//1.指向对象为该类型
//2.指向对象实现了该接口
if(o1 instanceof Coo){ //false
Coo o4 = (Coo)o1;
}
}
}
class Boo extends Aoo implements Inter1{
int num1;
void b(){}
public void a(){}
}
class Coo extends Aoo{
int num2;
void c(){}
void b(){}
}
interface Inter1{
void a();
}
abstract class Aoo{
abstract void b();
}