面向对象
面向对象是对面向过程的编程方式进行改进的一种思想;面向对象时一种设计程序、部署程序结构的思路,其核心宗旨是将程序中的各个功能细化;面向对象的特征:封装、继承、多态。
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 人为抽象的一种编程模型
* 将问题分解成一个一个独立的小问题,通过解决每个小问题,来解决大问题
面向对象的思想
如果将对象比作汽车,那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计,而不是对象的设计。
类
对象(实例)
引用
构造方法
this
方法重载
继承
super
方法重写
多态
向上转型
向下转型
instanceof
抽象类
final
static
访问控制符
接口
内部类
类
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 类比成“图纸”
* 对事物、算法、逻辑、概念的抽象
* 把相关的属性数据和逻辑运算方法进行封装,封装成一个类,形成一个独立的程序组件
创建类
--------------------------------------------------------------------------
语法格式:
[< 修饰符>] class < 类名>{
[<属性声明>]
[<构造器声明>]
[<方法声明>]
}
说明:修饰符public:类可以被任意访问
类的正文要用{ }括起来
举例:
public class Person{
private int age ; //声明私有变量 age
public void showAge(int i) { //声明方法showAge
age = i;
}
}
声明属性
-------------------------------------------------------------------------------
语法格式:
[<修饰符>] 类型 < 属性名> [=初值] ;
说明:修饰符 private: 该属性只能由该类的方法访问。
修饰符 public: 该属性可以被该类以外的方法访问。
类型:任何基本类型,如int、boolean或任何类。
举例:
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
*)属性有时也称为:数据成员(数据),成员变量(变量)
声明方法:
----------------------------------------------------------------------------------------
语法格式:
<修饰符> <返回类型> <方法名>([< 参数表>]) {
[< 语句>]
}
说明: 修饰符:public,private,protected 等。
返回类型:return语句传递返回值。没有返回值:void。
举例:
public class Person{
private int age;
public int getAge() { return age; } //声明方法getAge
public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
*)方法有时也称为:成员函数(函数)
对象(实例)
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 类比成“产品”
* 每个对象占用独立的内存空间,保存各自独立的属性值
* 可以独立的控制一个对象,执行指定方法的代码
对象的创建和使用
-----------------------------------------------------------------
*)使用 new +构造方法 创建一个新的对象;
*)使用 “对象名.对象成员” 的方式访问对象成员(包括属性和方法);
举例:
public class Car { String brand; int highSpeed; public Car() { } public void go() { System.out.println( brand+"汽车以最高时速"+ highSpeed+"前进"); } public void stop() { System.out.println( brand+"汽车停止"); } }
右边测试代码结果为:
| public class Test1 { public static void main(String[] args) { /* * 1. 新建两个Car对象赋给 a,b * 2. 为 a 的两个属性赋值 * 3. 为 b 的两个属性赋值 * 4. 分别调用 a,b 的go() 方法 * 让汽车前进 * 5. 分别调用 a,b的stop() 方法 * 让汽车停止 */ Car a = new Car(); Car b = new Car(); a.brand = "别摸我"; a.highSpeed = 250; b.brand = "保+洁"; b.highSpeed = 30; a.go(); b.go(); a.stop(); b.stop(); } } |
各种类型成员变量的默认值
------------------------------------------------------------------------------------------------
引用
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 类比成“遥控器”
* 引用变量,保存一个对象的内存地址
* 使用引用变量,可以找到内存中一个对象的内存空间,并访问它的属性数据,或控制让它执行指定方法
* 引用的特殊值 null
null 空 不保存任何对象的内存地址
构造方法
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 创建构造方法
语法格式:
< 修饰符> <类名>([< 参数表>]) {
[< 语句>]
}
* 新建对象时执行的特殊方法
new Soldier()
new Car()
new Point()
new Point(2,3)
* 如果不编写构造方法,编译器编译时,会添加默认构造方法
public class Point {
public Point() {
}
}
* 构造方法作用:不知道(当一个类的实例对象刚产生时,这个类的构造方法就会被自动调用,我们可以在这个方法中加入要完成初始化工作的代码)
可以自己定义构造方法,并在其中编写任意代码
*) 常见用法: 对成员变量初始化(赋值)
* 构造方法重载 Overload
*) 可以定义多个不同参数的构造方法
* this(...)
*) 在构造方法中,调用其他重载的构造方法
*) 一般在参数少的方法中,调用参数多的方法
*) 参数处理代码,集中在一个方法中写,其他方法调用这段代码
*) 必须是首行代码
* this.成员
*) this 是一个特殊的引用,保存当前对象的内存地址
当前对象:正在调用的对象
*) 用 this 可以引用当前对象的成员
this.id
this.name
this.toString()
this.distance()
*) 如果有同名的局部变量,必须用 this 才能引用成员变量
方法重载 Overload
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 同名不同参
*)参数的数量不同
*)参数的数据类型不同
*)参数中不同的数据类型的顺序不同(无视参数名称)
* 重载的本质
------------------------------------------------------------------------------------
* Java根据方法名称、参数的数据类型序列来判断方法的唯一性,而不是仅通过方法名称,所以,重载的本质是多个方法
* 在程序运行时,会根据给出的参数值匹配到对应的方法
* 使用重载可以有效的解决方法的命名问题
继承
继承是一种利用已有的类,快速创建新的类的机制;被继承的类为父类,得到继承的类为子类;通过继承,子类将拥有父类全部属性和方法。
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 作用: 代码重用、代码复用
* A 继承 B
*) A 是 B 的子类
*) B 是 A 的父类
* 单继承
*) 一个子类,只能有一个父类
*) 一个父类,可以有多个子类
* 构造方法,不继承
* 新建子类对象的过程:
1) 新建父类对象
2) 新建子类对象
*) 两个对象绑定在一起,作为一个子类对象
*) 调用子类成员时,先找子类,再找父类
构造方法执行过程
--------------------------------------------------------------
1) 新建父类对象时,执行父类构造方法
2) 新建子类对象时,执行子类构造方法
*) 默认执行父类无参构造方法
super()
*) 手动调用父类有参构造方法
super(参数)
* 方法重写 Override
*) 继承的方法,对子类不适用,可以在子类中重写这个方法
*) super.xxxx()
在子类中重写一个方法时, 可以手动调用父类的同一个方法,来减少代码重复
super
---------------------------------
1. 重写时,调用父类同一个方法的代码
super.toString()
2. 手动调用父类构造方法
super(参数)
*) 必须是首行代码
多态
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 作用: 一致的类型
所有不同的子类型对象,都可以作为一致的父类型被处理
* 类型转换
*) 向上转型
*) 子类对象,转为父类型
*) 向上转型之后,只能调用父类中定义的通用成员;
不能调用子类中扩展的成员
*) 向下转型
被转为父类型的子类对象,再转回成子类型
* instanceof
*) 对真实类型及其父类型判断,
都返回 true
Shape s = new Line();
s instanceof Line true
s instanceof Shape true
抽象类
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 半成品类(没有完成的类)
* 作用:
*) 通用代码
*) 通用方法的定义
* 抽象类,不能创建对象(不能被实例化)
* 包含抽象方法的类,必须是抽象类
* 抽象类中,不一定有抽象方法
final
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 用来修饰变量、方法、类
final 变量
---------------------------------
* 变量的值不可变,成为“常量”
final int a = 10;
//a = 11;
final Point a = new Point(2,3);
a.x = 20; //对
//a = new Point(8,9);
final 方法
---------------------------------
* 不能在子类中重写
final 类
---------------------------------
* 不能被继承,没有子类
static
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 静态
* 静态成员属于类,而不属于对象
class A {
int i = 10;
static int j = 20;
}
* 一般调用静态成员,使用类名调用
A.j = 30;
* 什么时候使用静态
*) 使用原则: 能不用就不用
静态是“非面向对象”的语法
*) 使用场景:
*) 共享的数据
*) 常量
static final
*) 工具方法
Math.sqrt()
Math.random()
访问控制符
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 用来控制一个类,或类中的成员的访问范围
*) 选择原则: 尽量小范围访问
public 是与其他开发者的一个契约,公开的类或成员,会保持稳定不变
接口
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 极端的抽象类
* 作用: 结构设计工具,用来解耦合
* 用 interface 代替 class 关键字
* 用 implements 代替 extends 关键字
* 接口中只允许定义:
*) 公共的常量
*) 公共的抽象方法
*) 公共的内部类或内部接口
* 子类可以实现多个接口
class A implements B,C,D {
}
* 接口之间继承
interface A extends B,C,D {
}
内部类
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* 定义在类中、方法中、方法内的局部代码块中
* 非静态内部类
class A {
class Inner {
}
}
*) 非静态内部类的对象,依赖于外部类对象才能存在
A a = new A();
//使用外部类对象,来新建内部类对象
A.Inner i = a.new Inner();
*) 非静态内部类中,不能定义静态成员
* 静态内部类
class A {
static class Inner {
}
}
----
A.Inner i = new A.Inner();
* 局部内部类
class A {
Weapon f() {
class Inner implements Weapon {
}
Inner i = new Inner();
return i;
}
}
* 匿名内部类
Weapon w = new Weapon() {
...
};
*) 大括号是匿名类
*) new 新建这个匿名类的对象
*) Weapon 作为匿名类的父类型