封装继承多态笔记整理

封装 继承 多态

对象有三大特性：封装，继承，多态。

• 对象

Java是一门面向对象的语言，对象，在java中表达的形式就是类（class），包含了数据，行为的一个独立的编程单元。
也就是说，Java编程语言是建基于Class的。通过建立Class来模拟现实世界的对象。

实际上，通过属性和方法可以模拟世界上任何的对象。

• 概念：

封装：将内部细节隐藏类中用private隐藏属性，其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题。

继承：子类从父类得到属性和行为

多态：父类或接口可以指向子类实例父类定义的方法会在不同子类中出现不同实现

• 实现：

  ​

-① 封装的实现：

定义属性，构造方法，get set方法，tostring，hashcode，equals

public class Person {
private  String name;
private  int age;

public Person() {
	super();
	// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}	

@Override
public String toString() {
	return "Person [name=" + name + ", 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;
}}

② 继承的实现：

father

public class Father {
private String name;
public Father() {
	System.out.println("father wu can");
}
public Father(String name) {
	System.out.println("father yi ge can ");
	this.name = name;
}}

son

public class Son extends Father {
public String name;
public Son(String name) {
	System.out.println("son you yi ge can ");
	this.name = name;
}

public Son() {
	System.out.println("son wu can ");
}}

Test

public class Fatherson_Test {
public static void main(String[] args) {
	new Son();
}}

打印结果：

father wu can
son wu can

总结：

使用extends关键字，只有一个继承关系，父类的所有的不是private 的东西都可以使用。

可以继承的有：属性，静态属性，get，set，构造方法；

在父类实例化了，子类可以不用实例化。

排序：

【第一次new 类（静态块，实例块）：先父类静态块，子类静态块，父类实例块，子类实例块

还是new类加上构造器：（静态块，实例块，构造器）

先静态,再实例，后构造

加上属性初始化后new：

先执行类相关初始化，在执行实例相关的操作，先父，再子，】

单个类：构造器调另一个构造器：

this调子类在新的构造器中写this（已有的参数列表），必须第一行先输出无参构造，再输出一个，最后输出全部的参数的构造器

super（参数）调用父类构造器，必须第一行，若不写，则为super（默认无参构造器）没有无参构造器，调super（）出错：

重载，重写（覆盖）的概念：

①重载（重新加载）是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。

②覆盖（也叫重写）（重来再写）是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。即函数名和参数都一样，只是函数的实现体不一样。

③多态的实现：

接口interface ————USB

public interface USB {
	public void Realized();	
}

实现接口implements———— USB_drive（U盘）

public class USB_drive implements USB {
public void Realized() {
System.out.println("u盘链接");
	
}}

实现接口implements———— Phone（手机）

public class Phone implements USB {
	public void Realized() {
	System.out.println("手机链接");		
	}
}

实现接口implements———— Hard_Disk（硬盘）

public class Hard_Disk implements USB {
	public void Realized() {
	System.out.println("硬盘链接");		
	}
}

​ 实现——————computer

public class Computer {
public void beused(USB usb,String name) {
	System.out.println("USB被"+name+"使用");
	usb.Realized();
}}

测试：

public class Test {
public static void main(String[] args) {
	Computer computer =new Computer();
	computer.beused(new Phone(),"手机");
	computer.beused(new USB_drive(),"U盘");
	computer.beused(new Hard_Disk(),"硬盘");
	 
}}

结果：

USB被手机使用
手机链接
USB被U盘使用
u盘链接
USB被硬盘使用
硬盘链接

笔记整理：

可以把一个父类（接口）的引用指向一个子类的实例，称为向上造型，是多态的典型表现
向上造型，只能访问父类（或接口）的方法，不能使用其他方法，
调用时，真正执行的是子类（或实现类）的方法.
我的理解：
【将一个接口指向实现类或将一个父类引用指向子类实例，称向上造型（左，大）（,俯视图最先看见的是较大的那个接口，）只能使用上面的那个类（[左边，大的那个接口]或[extends，implements 右边的那个接口或抽象类]），
person zs=new  zhangsan（）；
】
简单来说：向上转型，访问父类接口(person)，执行子类方法(zs.dosomething())
【zs.dosomething();】
隐式转换// 小转大 隐式


向下转型：显示转换（强转）// 大转小 显式 / 强制



多态参数：
对于向上造型，当方法的参数为上层类型，可以传入下层类型

• 好处

①封装的好处：

1、提高了代码的复用性。
2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3、提高了安全性。

②继承的好处：

a：提高了代码的复用性

b：提高了代码的维护性

c：让类与类之间产生了关系，是多态的前提

③多态的好处：

可替换：多态可以对已存在的代码，来替换（只要子类实现了接口的方法，可以替换父类的类）
可扩充性：新加的子类不影响已存在多态性、继承性、以及其他特性的运行和操作
接口性：多态是超类通过方法签名，像子类提供了一结构性
灵活性：灵活多样的操作，提高了使用效率
简化性：多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时