在学习面向对象编程语言时,封装、继承、多态则是我们必须学习和使用的三大特征。
本文通过举例,说明了该三大特征的基本权限特点。
范围 | private | 默认权限 | protected | public |
---|---|---|---|---|
同一包中的同一类 | √ | √ | √ | √ |
同一包中的不同类 | √ | √ | √ | |
不同包中的子类 | √ | √ | ||
不同包中的非子类 | √ |
注:访问权限用来控制方法或成员变量能否直接在类外使用。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。
顾名思义,保护或防止类中的属性或方法被破坏,同时又提供一个接口,使对象可以使用该对象的封装属性或方法。
主要使用private关键字。
通过创建一个Stu类,在Main类创建Stu对象,访问该对象属性和方法举例说明。
class Stu{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private void print(String name){
System.out.println(name + "在学习");
}
public void getPrint(String name){
print(name);
}
}
public class Main {
public static void main(String[] args) {
Stu stu = new Stu();
stu.setName("大佬");
stu.getPrint( stu.getName() );
}
}
输出结果为:
在该代码中,使用private修饰的属性和方法均属于私有成员,在该类外不能直接访问和使用。于是我们通过setName/getName()/getPrint间接访问和使用,这里的setName/getName()/getPrint就是对外公开的接口。
继承:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性 的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构,体现了 由简单到复杂的认知过程。
例如下图关系:
父类具有的属性和方法,在子类当中都可以通过super关键字访问和使用。如果是创建了子类对象,也可以正常访问父类的内容,如果父类方法发生了重写,则需要通过super.方法(参数)访问和使用。
继承的使用,可以大大提高代码的简化,使同一段代码重复使用。
注意: 1. 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构 造方法 。 2. 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的 父类构造方法调用,否则编译失败。 3. 在子类构造方法中,super(...)调用父类构造时,必须是子类构造函数中第一条语句。 4. super(...)只能在子类构造方法中出现一次,并且不能和this同时出现。
通过创建一个Tree类, 再创建一个OsmanthusTree类继承Tree类,访问该对象属性和方法举例说明。
class Tree{
String name;
public String age;
public static String ascription;//归属
public String function;//作用
static{
ascription = "中国持有";
}
public void springSprout(String name){
System.out.println(this.name + "发芽");
}
}
class OsmanthusTree extends Tree{
private String disease;//该树患病
public String getDisease() {
return disease;
}
public void setDisease(String disease) {
this.disease = disease;
}
}
public class Inherit {
public static void main(String[] args) {
OsmanthusTree osmanthusTree = new OsmanthusTree();
osmanthusTree.name = "小❀❀";
osmanthusTree.setDisease("白蚁吞噬");
System.out.println(osmanthusTree.name + osmanthusTree.getDisease());
System.out.println(osmanthusTree.name + "治疗之后");
osmanthusTree.springSprout( osmanthusTree.name );
}
}
输出结果为:
在该代码中,使用 extends 连接Tree类和 OsmanthusTree类。 OsmanthusTree类为子类,Tree类为父类,在 OsmanthusTree中可以访问Tree的所有属性和方法。
也就是说,在子类中可以访问父类的所有属性和方法(私有权限除外)。
多态:同一件事情,发生在不同对象身上,就会产生不同的结果。 比如下图示意:
通过创建一个父类Creature, 再创建Person类和Cat类继承Creature类,访问该对象属性和方法举例说明。
class Creature{
String name;
int age;
public Creature(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(this.name + "在吃午饭");
}
}
class Person extends Creature{
public Person(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(this.name + "在吃米饭");
}
}
class Cat extends Creature{
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(this.name + "在吃猫粮");
}
}
public class Polymorphism {
public static void test(Creature creature){
creature.eat();
}
public static void main(String[] args) {
test(new Person("人类", 19));
System.out.println("===========");
test(new Cat("小猫", 2));
System.out.println("===========");
}
}
输出结果:
由输出结果可知,不同的子类继承父类,在该类中重写了某个方法之后,又使用该被重写的方法,会得到不同的结果。这就是多态带来的便利,同时我们也可以得知多态实现的几个必要条件:
上述代码展示和图文说明就是封装、继承、多态的全部啦。
这篇博客如果对你有帮助,给博主一个免费的点赞以示鼓励,欢迎各位🔎点赞👍评论收藏⭐,谢谢!!!
如果有什么疑问或不同的见解,欢迎评论区留言哦。