面向对象--02--封装继承多态

Posted 2021-07-25 高高for 循环

面向对象

• 所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。
• 我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）

三大特征

1. 封装性，把相关的数据封装成一个“类”组件
2. 继承性，是子类自动共享父类属性和方法，这是类之间的一种关系
3. 多态，增强软件的灵活性和重用性
   

封装

–概述

1. 封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。

–好处

1. 提高安全性
2. 提高重用性

–案例

1. .类
2. 方法
   
   
   

四种访问权限修饰符

继承

–概述

• 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

–好处

• 提高代码的复用性 能够大大缩短开发周期，降低开发费用。

– 特点

1. 使用extends关键字
2. 相当于子类把父类的功能复制了一份
3. java只支持单继承
4. 继承可以传递（爷爷，儿子，孙子的关系）
5. 不能继承父类的私有成员
6. 继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7. 像是is a 的关系

– 特点super关键字

1. 通过super关键字可以使用父类的内容

2. super代表父类的一个引用对象

3. 如果用，必须出现在调用位置的第一行
   

– 方法的重写

1. 继承后，子类就拥有了父类的功能

2. 那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能

3. 子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能

注意：

1、父类中的私有方法不能被重写

2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

– 构造方法的使用

4. 子类创建对象时，默认会去访问父类的无参构造方法

5. 在构造方法的第一行，都有一条默认的语句：super();

6. 父类没有无参构造时，可以用super调用父类的其他构造

继承的内存结构

子类对象实例化过程:

子类继承父类，子类拥有了父类的所有属性和方法

1. 子类继承父类，子类拥有了父类的所有属性和方法
2. 程序验证，父类的私有属性和方法子类是无法直接访问的。当然私有属性可以通过public修饰的getter和setter方法访问到的，但是私有方法不行。

分析:

• 分析内存后，会发现，当一个子类被实例化的时候，默认会先调用父类的构造方法对父类进行初始化，即在内存中创建一个父类对象，然后再父类对象的外部放上子类独有的属性，两者合起来成为一个子类的对象。
• 所以：子类继承了父类的所有属性和方法或子类拥有父类的所有属性和方法是对的，只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。

内存图：Student extends People

案例:

public String name; 属性公有

public class Test02 {

    public static void main(String[] args) {

        Son son = new Son();

        son.setName("jack");
        String name = son.getName();

        System.out.println("son.getName(): "+name);
        System.out.println("son.name: "+son.name);
        son.tell();

    }
}


abstract class Father{
    
    public String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


class Son extends Father{
    
    public void tell(){
       String s =  super.name;
       System.out.println("super.name:  "+s);
    }
}

private String name; 属性私有

public class Test02 {

    public static void main(String[] args) {

        Son son = new Son();

        son.setName("jack");
        String name = son.getName();

        System.out.println("son.getName(): "+name);
     
    }
}


abstract class Father{

   private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


class Son extends Father{
    
    public void tell(){

    }

}

多态

–概念

• 多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。
• 主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

重写是父类与子类之间多态性的一种表现

重载是一类中多态性的一种表现

–好处

1. 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2. 提高了程序的扩展性和可维护性

–前提

1. 多态的前提是继承
2. 要有方法的重写

–特点

父类引用指向子类对象,

如：Animal a = new Dog(); – 小到大，向上转型

多态中，编译看左边，运行看右边

–使用:

1. 成员变量：使用的是父类的
2. 成员方法：由于存在重写现象所以使用的是子类的
3. 静态成员：随着对象而存在，谁调用的就返回谁的

多态的案例分析:

Objects 的 equals(Object obj)

子类调用equals()方法时 ,一般都是调用Object 子类实例作为参数.参数不同类型体现了多态.

jdbc获取数据库连接

public static void main(String[] args) throws Exception {
    //1.注册数据库驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.获取数据库连接
    Connection conn = DriverManager.getConnection(
        "jdbc:mysql://localhost:3306/jt_db?characterEncoding=utf-8",
        "root", "root");
    //3.获取传输器
    Statement stat = conn.createStatement();
    //4.发送SQL到服务器执行并返回执行结果
    String sql = "select * from account";
    ResultSet rs = stat.executeQuery( sql );
    //5.处理结果
    while( rs.next() ) {
        int id = rs.getInt("id");
        String name = rs.getString("name");
        double money = rs.getDouble("money");
        System.out.println(id+" : "+name+" : "+money);
    }
    //6.释放资源
    rs.close();
    stat.close();
    conn.close();
    System.out.println("TestJdbc.main()....");
}
                                               

获取数据库连接Connection 是个接口实例,这样便可以根据不同产商提供的连接不同.体现多态.提高了代码的复用性.

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

多态是运行时行为

class Animal  {
 
	protected void eat() {
		System.out.println("animal eat food");
	}
}

class Cat  extends Animal  {
 
	protected void eat() {
		System.out.println("cat eat fish");
	}
}

class Dog  extends Animal  {
 
	public void eat() {
		System.out.println("Dog eat bone");

	}

}

class Sheep  extends Animal  {
 

	public void eat() {
		System.out.println("Sheep eat grass");

	}

 
}

public class InterviewTest {

	public static Animal  getInstance(int key) {
		switch (key) {
		case 0:
			return new Cat ();
		case 1:
			return new Dog ();
		default:
			return new Sheep ();
		}

	}

	public static void main(String[] args) {
		int key = new Random().nextInt(3);

		System.out.println(key);

		Animal  animal = getInstance(key);
		
		animal.eat();
		 
	}

}