面向对象
面向对象是一种以对象为中心的编程思想,通过指挥对象实现具体的功能。
面向过程
是一种以过程为中心的编程思想,实现功能的每一步,都是自己实现的
对象
指客观存在的事物,万物皆对象
对象的创建和使用
类名 对象名 = new 类名();
范例
Student s = new Student();
使用对象
使用成员变量
格式:对象名.变量名
范例:p.name
使用成员方法
格式:对象名.方法名()
范例:p.study();
面向对象三大特征
封装,继承,多态
1封装
隐藏实现细节,仅对外暴露公共的访问方式。比如插线板。
封装的体现
1.1属性私有化,并对外提供方法(方法内做判断)进行操作
例如以下代码
class Student {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 0 && age <= 200) {
this.age = age;
} else {
System.out.println(“请检查年龄数值”);
}
}
}
1.2将代码抽取到方法中,这是对代码的一种封装
1.3.将属性抽取到类当中,这是对数据的一种封装。
封装的好处
- 提高了代码的安全性
- 提高了代码的复用性
构建、创造对象的时候,所调用的方法。封装时需要构造方法
- 格式
- 方法名与类名相同,大小写也要一致
- 没有返回值类型,连void都没有
- 没有具体的返回值(不能由retrun带回结果数据)
构造方法的作用
本质作用是创建对象,但是也可以用于给对象的数据(属性)进行初始化。
构造方法创建注意事项
-
如果没有定义构造方法,系统将给出一个默认的无参数构造方法。
-
如果定义了构造方法,系统将不再提供默认的构造方法。
构造方法的重载
- 如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法。
推荐的使用方式 - 无论是否使用,都手动书写无参数构造方法,和带参数构造方法。
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println(name + "..." + age);
}
}
public class TestStudent {
public static void main(String[] args) {
// 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName(“张三”);
stu1.setAge(23);
stu1.show();
// 2. 通过带参数构造方法, 直接给属性进行赋值
Student stu2 = new Student("李四",24);
stu2.show();
}
}
2. 继承
2.1继承的概念
-
继承是面向对象三大特征之一,可以使得子类具有父类的属性和方法,还可以在子类中重新定义,以及追加属性和方法
-
实现继承的格式
-
继承通过extends实现
-
格式:class 子类 extends 父类 { }
- 举例:class Dog extends Animal { }
继承带来的好处
- 举例:class Dog extends Animal { }
-
继承可以让类与类之间产生关系,子父类关系,产生子父类后,子类则可以使用父类中非私有的成员。
- 继承好处 -
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
-
提高了代码的维护性(如果方法的代码需要修改,修改一处即可)
继承弊端 -
继承让类与类之间产生了关系,类的耦合性增强了,当父类发生变化时子类实现也不得不跟着变化,削弱了子类的独立性
-
继承的应用场景:
-
使用继承,需要考虑类与类之间是否存在is…a的关系,不能盲目使用继承
2.2继承的特点
继承的特点
-
Java中类只支持单继承,不支持多继承
- 错误范例:class A extends B, C { }
-
Java中类支持多层继承
多层继承示例代码
public class Granddad {public void drink() {
System.out.println(“爷爷爱喝酒”);
}
}
public class Father extends Granddad {
public void smoke() {
System.out.println("爸爸爱抽烟");
}
}
public class Mother {
public void dance() {
System.out.println("妈妈爱跳舞");
}
}
public class Son extends Father {
// 此时,Son类中就同时拥有drink方法以及smoke方法
}
2.2.1继承中变量的访问特点
在子类方法中访问一个变量,采用的是就近原则。
- 子类局部范围找
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
2.2 .2 super
this&super关键字:
this:代表本类对象的引用
super:代表父类存储空间的标识(可以理解为父类对象引用) this和super的使用分别
成员变量:
this.成员变量 - 访问本类成员变量
super.成员变量 - 访问父类成员变量
成员方法:
this.成员方法 - 访问本类成员方法
super.成员方法 - 访问父类成员方法
构造方法:
this(…) - 访问本类构造方法
super(…) - 访问父类构造方法
2.2.3继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中无参的构造方法*
子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化,原因在于,每一个子类构造方法的第一条语句默认都是:super()
2.2.4 继承中成员方法的访问特点(掌握)
通过子类对象访问一个方法
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
2.2.5 方法重写
-
1、方法重写概念
- 子类出现了和父类中一模一样的方法声明(方法名一样,参数列表也必须一样)
-
2、方法重写的应用场景
- 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容
-
3、Override注解
-
2.2.6方法重写的注意事项
-
私有方法不能被重写(父类私有成员子类是不能继承的)
-
子类方法访问权限不能更低(public > 默认 > 私有)
-
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
public class Fu {
private void show() {
System.out.println(“Fu中show()方法被调用”);
}void method() {
System.out.println(“Fu中method()方法被调用”);
}
}
public class Zi extends Fu {
/* 编译【出错】,子类不能重写父类私有的方法*/
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
/* 编译【出错】,子类重写父类方法的时候,访问权限需要大于等于父类 */
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}
/* 编译【通过】,子类重写父类方法的时候,访问权限需要大于等于父类 */
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}
}
权限修饰符
3多态
3.1多态的概述(记忆)
-
什么是多态
同一个对象,在不同时刻表现出来的不同形态
-
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象
class Animal {
public void eat(){
System.out.println(“动物吃饭”);
}
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println(“猫吃鱼”);
}
}
public class Test1Polymorphic {
/*
多态的前提:
1. 要有(继承 \ 实现)关系
2. 要有方法重写
3. 要有父类引用, 指向子类对象
*/
public static void main(String[] args) {
// 当前事物, 是一只猫
Cat c = new Cat();
// 当前事物, 是一只动物
Animal a = new Cat();
a.eat();
}
}
3.2多态中的成员访问特点
-
成员访问特点
-
成员变量
编译看父类,运行看父类
-
成员方法
编译看父类,运行看子类
-
-
代码演示
class Fu {
int num = 10;public void method(){
System.out.println(“Fu… method”);
}
}
class Zi extends Fu {
int num = 20;
public void method(){
System.out.println("Zi.. method");
}
}
public class Test2Polymorpic {
/*
多态的成员访问特点:
成员变量: 编译看左边 (父类), 运行看左边 (父类)
成员方法: 编译看左边 (父类), 运行看右边 (子类)
*/
public static void main(String[] args) {
Fu f = new Zi();
System.out.println(f.num);
f.method();
}
}
3.3多态的好处和弊端
-
好处
提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
-
弊端
不能使用子类的特有成员
3.4多态中的转型
3.4多态中的转型(应用)
-
向上转型
父类引用指向子类对象就是向上转型
-
向下转型
格式:子类型 对象名 = (子类型)父类引用;
代码演示
class Fu {
public void show(){
System.out.println(“Fu…show…”);
}
}
class Zi extends Fu {
@Override
public void show() {
System.out.println(“Zi…show…”);
}
public void method(){
System.out.println("我是子类特有的方法, method");
}
}
public class Test3Polymorpic {
public static void main(String[] args) {
// 1. 向上转型 : 父类引用指向子类对象
Fu f = new Zi();
f.show();
// 多态的弊端: 不能调用子类特有的成员
// f.method();
// A: 直接创建子类对象
// B: 向下转型
// 2. 向下转型 : 从父类类型, 转换回子类类型
Zi z = (Zi) f;
z.method();
}
}
3.5多态中转型存在的风险和解决方案
- 风险
如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException - 解决方案
- 关键字
instanceof - 使用格式
变量名 instanceof 类型
通俗的理解:判断关键字左边的变量,是否是右边的类型,返回boolean类型结果
abstract class Animal {
public abstract void eat();
}
- 关键字
class Dog extends Animal {
public void eat() {
System.out.println(“狗吃肉”);
}
public void watchHome(){
System.out.println("看家");
}
}
class Cat extends Animal {
public void eat() {
System.out.println(“猫吃鱼”);
}
}
public class Test4Polymorpic {
public static void main(String[] args) {
useAnimal(new Dog());
useAnimal(new Cat());
}
public static void useAnimal(Animal a){ // Animal a = new Dog();
// Animal a = new Cat();
a.eat();
//a.watchHome();
// Dog dog = (Dog) a;
// dog.watchHome(); // ClassCastException 类型转换异常
// 判断a变量记录的类型, 是否是Dog
if(a instanceof Dog){
Dog dog = (Dog) a;
dog.watchHome();
}
}
}