面向对象

面向对象

面向对象是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。
面向过程

是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
对象

指客观存在的事物，万物皆对象
对象的创建和使用
类名 对象名 = 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.将属性抽取到类当中，这是对数据的一种封装。

封装的好处

• 提高了代码的安全性
• 提高了代码的复用性

构建、创造对象的时候，所调用的方法。封装时需要构造方法

• 格式

1. 方法名与类名相同，大小写也要一致
2. 没有返回值类型，连void都没有
3. 没有具体的返回值（不能由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 { }
    继承带来的好处

• 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
  - 继承好处

• 提高了代码的复用性(多个类相同的成员可以放到同一个类中)

• 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
  继承弊端

• 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

• 继承的应用场景：

• 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
  2.2继承的特点
  继承的特点

1. Java中类只支持单继承，不支持多继承

   • 错误范例：class A extends B, C { }

2. 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继承中变量的访问特点
在子类方法中访问一个变量，采用的是就近原则。

1. 子类局部范围找
2. 子类成员范围找
3. 父类成员范围找
4. 如果都没有就报错(不考虑父亲的父亲…)
   2.2 .2 super
   this&super关键字：

this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用) this和super的使用分别
成员变量：
this.成员变量 - 访问本类成员变量
super.成员变量 - 访问父类成员变量
成员方法：
this.成员方法 - 访问本类成员方法
super.成员方法 - 访问父类成员方法
构造方法：
this(…) - 访问本类构造方法
super(…) - 访问父类构造方法

2.2.3继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中无参的构造方法*

​ 子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()
2.2.4 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

1. 子类成员范围找
2. 父类成员范围找
3. 如果都没有就报错(不考虑父亲的父亲…)
   2.2.5 方法重写

• 1、方法重写概念

  • 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

• 2、方法重写的应用场景

  • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

• 3、Override注解

  • 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

  • 2.7 方法重写的注意事项（掌握）

• 2.2.6方法重写的注意事项

1. 私有方法不能被重写(父类私有成员子类是不能继承的)

2. 子类方法访问权限不能更低(public > 默认 > 私有)

3. 静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
   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();
    }
}

}