OO;面向对象
OOA:面向对象分析
OOD:面向对象设计
OOP;面向对象编程
什么是类？什么是对象？
现实生活中是由很多很多对象组成的，基于对象抽出了类
对象：软件中真实存在的单个个体/东西
类：类别/类型，代表一类个体
类是对象的模子，对象是类的具体的实例
类中可以包含：
对象的属性/特征-----------------------成员变量
对象的行为/动作-----------------------方法
一个类可以创建多个对象
方法的重载(overload/overloading)：---------------更加方便用户的访问
- 发生在同一类中，方法名相同，参数列表不同
- 编译器在编译时会根据方法的签名自动绑定方法
- 复用性好、扩展性好、维护性好、可移植性好\健壮性好、可读性好、效率好…
-
方法的签名：方法名+参数列表
默认规则:
byte,short,int,long,char----------默认值 0
float,double-------------------------默认值 0.0
boolean------------------------------默认值 false
引用类型-----------------------------默认值 null
//若想访问对象，需要通过引用zs
引用
数据类型 引用类型变量 指向 对象
Student zs = new Student();
构造方法：构造函数、构造器、构建器---------复用给成员变 量赋初值代码
作用：给成员变量赋初始值
与类同名，没有返回值类型(连void都没有)
在创建(new)对象时被自动调用
若自己不写构造方法则编译器默认提供一个无参构造方法:若自己写了构造方法，则不再默认提供
(重载与返回值类型无关)(重载与参数名称无关)
构造方法可以重载
this 只能用在方法中 方法中访问成员变量之前默认有个this
this：指代当前对象，哪个对象调用方法它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法：
this.成员变量名-------------访问成员变量
成员变量与局部变量同名时，若想访问成员变量 则this不能省略
-
this.方法名()-----------------调用方法(了解)
-
this()---------------------------调用构造方法(了解)
null：表示空，没有指向任何对象 若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空指针异常
成员变量：写在类中，方法外--------有默认值
局部变量：方法中------------------------没有默认值
成员变量和局部变量是可以同名的：
----使用的时候默认采取就近原则
----若想访问成员变量，则this不能省略
内存管理：由JVM来管理的
https://mp.youkuaiyun.com/mp_blog/creation/editor/136351864
堆：new出来的对象(包括成员变量)
栈：局部变量(包括方法的参数)
数组也是一个对象，所以数组对象也存储在堆中，
将数组的元素当作成员变量一并存储在堆中
引用类型数组：
与基本类型数组的区别：
给数组元素赋值必须new一下
若想访问对象 数据必须通过数组元素打点
System.out.println (stus[0].name);//输出第1个学生的名字//2)访问数据需要通过数组元素打点
stus[1].age = 24;//修改第二个元素的年龄为24
继承：(要符合is(是)的关系
作用：代码复用
通过extends来实现继承
超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
派生类既能访问自己的，也能访问超类，但是超类不能访问派生类的
一个超类可以有多个派生类，一个派生类只能有一个超类---------单一继承
具有传递性
继承的是超类的成员变量和普通方法,而不包括构造方法,
构造方法是被派生类通过supper来调用的
java规定：
构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法
在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供
super()调用超类构造方法，必须位于派生类构造方法的第1行
super：指代当前对象的超类对象
super的用法:
super.成员变量名---------------------访问超类的成员变量
super.方法名()-------------------------调用超类的方法
super()-----------------------------------调用超类的构造方法
向上造型：
- 超类型的引用指向派生类的对象
- 能点出来什么，看引用的类型
- 向上造型的意义：--------实现代码复用
- 当多种角色能干的事是一样的，可以将那多种角色造型到超类数组中，统一访问
方法的重写：重新写
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型
- 重写遵循"两同两小一大"原则
两同：
方法名相同
参数列表相同
两小：
派生类方法的返回值类型小于或等于超类方法的
void和基本类型时，必须相等
引用类型时，小于或等于
派生类方法抛出的异常小于或等于超类方法的
一大：
派生类方法的访问权限大于或等于超类方法的
重写与重载的区别：
- 重写(override)：发生在父子类中，方法名相同，参数列表相同
- ---用于在派生类中修改超类中所声明的方法
- 重载(overload)：发生在同一类中，方法名相同，参数列表不同
- ---完全不同的方法,只是方法名正好相同
import javax.swing.*;
public class World extends JPanel {
public static void main(String[] args) {
JFrame frame = new JFrame();
World world = new World();
world.setFocusable(true);
frame.add(world);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(641+16, 479+39);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
package和import：
package：声明包
避免类的命名冲突
同包中的类不能同名，但不同包中的类可以同名
类的全称：包名.类名
包名常常用层次结构，建议所有字母都小写
import：导入类
同包中的类可以直接访问
不同包中的类不能直接访问，若想访问：
先import声明类，再访问类
类的全称
访问控制修饰符：---保证数据的安全
public：公开的，任何类 (行为{方法})
private：私有的，本类 (数据{成员变量})
protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类
说明：
- 类的访问权限只能是public或默认的
- 类中成员的访问权限如上4种都可以
- 访问权限由高到低依次为：public>protected>默认的>private
成员变量
实例变量:没有static修饰,属于对象的,存储在堆中,有几个对象就有几份
通过引用(对象)点来访问
静态变量:由static修饰,属于类的,存储在方法区中,只有一份
通过类名点来访问
final：最终的、不可改变的
- 修饰变量：变量不能被改变
- 修饰方法：方法不能被重写
- 修饰类：类不能被继承
static：静态的
public static void main(String[] args){
Loo o1 =new Loo();
o1.show();
Loo o2 =new Loo();
o2.show();
Loo o3 =new Loo();
o3.show();
}
//演示静态变量
class loo{
int a;
static int b;
Loo(){
a++;
b++;
}
void show(){
System.out.println("a="+a+",b="+b);}
}
- 静态变量：
- 由static修饰
-
int a;//实例变量(通过对象来访问) static int b;//静态变量(通过类名来访问) - 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)
-
public static void main(String[] args){ Loo o1 =new Loo(); o1.show(); Loo o2 =new Loo(); o2.show(); Loo o3 =new Loo(); o3.show(); } //演示静态变量 class loo{ int a;//实例变量(对象点来访问) static int b;//静态变量(类名点来访问) Loo(){ a++; b++; } void show(){//有隐式this System.out.println(this.a); System.out.println(Loo .a);} Static void test(){//没有隐式this //静态方法中没有隐式this传递 //没有this意味着没有对象 //而实例变量a必须通过对象名点来访问 //所以如下代码发生编译错误 System.out.printle(a);//编译错误 System.out.printle(Moo.a); } - 静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，不能直接访问实例成员
- ---(普通方法(有隐式this))---
- 何时用：方法的操作与对象无关
- 静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
- 何时用：加载/初始化静态资源(图片、音频、视频等)
静态块: 初始化静态变量
构造方法: 初始化实例变量
数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
成员变量分两种：
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
通过引用(对象)点来访问
静态变量：由static修饰，属于类的，存储在方法区中，只有一份
通过类名点来访问
内存管理：由JVM来管理
堆：new出来的对象(包括实例变量)
栈：局部变量(包括方法的参数)
方法区：.class字节码文件(包括静态变量、所有方法)
static final常量：
- 必须声明同时初始化
- 类名点来访问，不能被改变
- 建议：常量名所有字母都大写，多个单词用_分隔
- 编译器在编译时会将常量直接替换为具体的数，效率高
- 何时用：数据永远不变，并且经常使用
设计规则:
将共有的属性和行为,抽到超类中 --------抽共性
若对象行为都一样,设计为普通方法,
若行为对象不一样,设计为抽象方法
抽象方法：
由abstract修饰
只有方法的定义，没有具体的实现(连{}都没有)
抽象类：
由abstract修饰
包含抽象方法的类必须是抽象类, 抽象类不能被实例化(new对象), 抽象类是需要被继承的，
派生类：
重写所有抽象方法-----------------变不完整为完整
也声明为抽象类---------------------一般不这么用
抽象类的意义：
封装共有的属性和行为---------------代码复用
为所有派生类提供统一的类型------向上造型
可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，
派生类的行为不同，但入口是一致的，同时相当于定义了一个标准(强制重写)
设计规则：
将共有的属性和行为，抽到超类中-------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
抽象方法/抽象类的疑问:
抽象方法存的意义是什么？
保证当发生向上造型时，通过超类的引用能点出来那个方法
既然意义只在于能点出来，那为什么不设计为普通方法呢？
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写
没有抽象方法的类也可以声明抽象类,只要是抽象类一定不能实例化
成员内部类：应用率低-
类中套类，外面的称为外部类，里面的称为内部类
内部类通常只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this-
匿名内部类：---大大简化代码
- 若想创建一个类(派生类)的对象，并且对象只被创建一次，可以做成匿名内部类
- 在匿名内部类中默认外面的变量为final的 隐式的引用：
内部类有独立的.class
this：指代当前对象
super：指代当前对象的超类对象
外部类名.this：指代当前对象的外部类对象
做功能的套路：
1)先写行为/方法：
2)若为某对象所特有的行为，则将方法设计在特定的类中
3)若为所有对象所共有的行为，则将方法设计在超类中
窗口调用：
若为定时发生的，则在定时器中调用
若为事件触发的，则在侦听器中调用
接口：
- 是一种引用数据类型
- 由interface定义
- 只能包含常量和抽象方法
- 接口不能被实例化(new对象)
- 接口是需要被实现/继承的，实现类/派生类：
----必须重写所有抽象方法 - 一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现
- 接口可以继承接口
关系：
类和类---------------------继承extends
接口和接口---------------继承extends
类和接口------------------实现implements
设计规则：
将所有派生类所共有的属性和行为，抽到超类中---------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展---------------------------实现多继承
接口的意义：
实现多继承
制定了一套标准、规则
多态：
意义：
同一类型的引用指向不同的对象时，有不同的实现--------所有抽象方法都是多态的
----行为的多态：cut()、getImage()、move()…
同一个对象被造型为不同的类型时，有不同的功能--------所有对象都是多态的
----对象的多态：我、你、水…
向上造型/自动类型转换：
超类型的引用指向派生类的对象
能点出来什么，看引用的类型
能造型成为的数据类型有：超类+所实现的接口
强制类型转换，成功的条件只有如下两种：
引用所指向的对象，就是该类型
引用所指向的对象，实现了该接口或继承了该类
强转时若不符合如上条件，则发生ClassCastException类型转换异常
建议在强转之前先通过instanceof判断引用的对象是否是该类型
面向对象三大特征：
封装
类：封装的是对象的属性和行为
方法：封装的是具体的业务逻辑功能实现
访问控制修饰符：封装的是具体的访问权限，以保护数据的安全
继承：
作用：代码复用
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
单一继承、多接口实现，具有传递性
多态：
行为多态：所有抽象方法都是多态的(通过方法的重写实现的)
对象多态：所有对象都是多态的(通过向上造型来实现)
向上造型、强制类型转换、instanceof判断
扫一扫
1742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
