面向对象

设计原则：
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();
}