面向对象特征的说明
面向对象特点：封装、继承、多态。(如果要回答四个，可加上抽象性这一特点)
- 继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
- 继承性：
- 封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
- 封装性：
- 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
- 多态性：
- 抽象性：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
- 抽象性：
1. 封装性：
1.1 为什么需要封装？封装的作用和含义？
- 追求“高内聚，低耦合”。
- 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合 ：仅对外暴露少量的方法用于使用。
- 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
1.2 信息的封装和隐藏
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:get()和set()实现对该属性的操作，以实现下述目的：
- 隐藏一个类中不需要对外提供的实现细节；
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
- 便于修改，增强代码的可维护性
代码示例：
class A {
private int num = 0;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class Example {
public static void main(String[] args) {
A a = new A();
System.out.println(String.format("num: %d", a.getNum()));
a.setNum(1);
System.out.println(String.format("num: %d", a.getNum()));
}
}
输出：
num: 0
num: 1
1.3 四种访问权限修饰符
- Java权限修饰符public、protected、(缺省)、private置于类的成员定义前， 用来限定对象对该类成员的访问权限。
- 对于class的权限修饰只可以用public和default(缺省)。
- public类可以在任意地方被访问。
- default类只可以被同一个包内部的类访问。
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| (缺省) | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
2. 继承性：
2.1 为什么要有继承？
- 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。(此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”)
2.2 类继承语法规则:
class Subclass extends SuperClass{}
2.3子类与父类
- 子类继承了父类，就继承了父类的方法和属性。
- 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
- 在Java中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
2.4继承规则
- 子类不能直接访问父类中私有的(private)的成员变量和方法。
- Java只支持单继承和多层继承，不允许多重继承 ：
- 一个子类只能有一个父类
- 一个父类可以派生出多个子类
2.5方法的重写
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法
要求：
- 子类重写的方法必须和父类被重写的方法具有**相同的方法名称、参数列表 **。
- 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型 。
- 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限 。
子类不能重写父类中声明为private权限的方法 。 - 子类方法抛出的异常不能大于父类被重写方法的异常 。
注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
class Person {
String name = "person";
private int age = 18;
String getinfo() {
return String.format("name: %s age: %d %n", name, age);
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Student extends Person {
String name = "student";
String school = "school";
String getinfo() {
return String.format("name: %s age: %d school: %s%n", name, getAge(), school);
}
}
public class InheritDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p = new Person();
System.out.println(p.getinfo());
Student s = new Student();
System.out.println(s.getinfo());
}
}
输出：
name: person age: 18
name: student age: 18 school: school
2.6 作用：
1. 继承的出现减少了代码冗余，提高了代码的复用性。
1. 继承的出现，更有利于功能的扩展。
1. 继承的出现让类与类之间产生了关系，提供了多态的前提。
- 注意：不要仅为了获取其他类中某个功能而去继承
3. 多态性
对象的多态性在Java中的体现：
父类的引用指向子类的对象 （可以直接应用在抽象类和接口上）
Java引用变量有两个类型：编译时类型和运行时类型。
编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性。
“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
对象的多态 在Java中,子类的对象可以替代父类的对象使用 ：
一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象 Person p = new Student();
子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
示例代码：
abstract class Animal {
String name = "animal";
public abstract String getinfo();
}
class Cat extends Animal {
String name = "cat";
int age = 3;
public String getinfo() {
return String.format("name: %s age: %d", name, age);
}
void sleep() {
System.out.println("The cat is asleep under the table.");
}
}
public class PolymorphicDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
String info;
Cat c = new Cat();
info = String.format("c:%nname: %s. %ninfo: %s", c.name, c.getinfo());
System.out.println(info);
c.sleep();
System.out.println();
Animal a = c;
info = String.format("a:%nname: %s. %ninfo: %s", a.name, a.getinfo());
System.out.println(info);
// a.sleep() 无效，父类没有sleep()方法
System.out.println();
Cat c1 = (Cat) a;
info = String.format("c1:%nname: %s. %ninfo: %s", c1.name, c1.getinfo());
System.out.println(info);
c.sleep();
System.out.println(String.format("c与c1是否为同一地址: %b", c1 == c));
}
}
输出：
c:
name: cat.
info: name: cat age: 3
The cat is asleep under the table.
a:
name: animal.
info: name: cat age: 3
c1:
name: cat.
info: name: cat age: 3
The cat is asleep under the table.
c与c1是否为同一地址: true
多态小结
- 多态作用：
提高了代码的通用性，常称作接口重用 - 前提：
需要存在继承或者实现关系
有方法的重写 - 成员方法：
编译时：要查看引用变量所声明的类中是否有所调用的方法。
运行时：调用实际new的对象所属的类中的重写方法。 - 成员变量：
不具备多态性，只看引用变量所声明的类。
