Java三大特性-CSDN博客

本文链接：https://blog.csdn.net/Colorful_X/article/details/109697528

文章目录

Java的三大特性

Java的三大特性

(一) 封装性

我们将类中的属性声明私有化(将属性声明为private),同时提供相应的 setXxx和getXxx() 去设置和获得其对应的属性。被我们声明为private的属性，不能在该类的外部通过 “对象名.属性” 的方式去访问该属性。

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(18);
        p1.setName("张某");
        p1.info();
//      p1.age = 10; 这样写是错的。
    }
}

class Person{
    private int age;
    private String name;

    // 提供age的get()方法
    public int getAge(){
        return age;
    }

    // 提供name的get()方法
    public String getName(){
        return name;
    }

    // 提供name的set()方法
    public void setName(String name){
        this.name = name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public void info(){
        System.out.println("姓名: "+name+",年龄: "+age);
    }
}

(二) 继承性

① 关于继承的规定
Java中只支持单继承，不支持多继承，即一个子类只能有一个直接父类。但一个父类可以有多个子类(即一个父类可以被多个子类继承)。

② 继承性的使用:
格式： class A extends B{ }
其中A是子类(也可叫派生类),B是父类(也可叫基类)。

继承性的体现：
1). 一旦子类继承父类以后，子类就获取了父类中声明的结构：属性、方法等。特别地，父类中声明为private的属性或方法，子类也同样会获得，只不过由于封装性，使得子类不能直接调用父类中的这些方法。

2).子类继承父类的方法和属性后，还可以自定义属于自己的属性和方法，实现功能的拓展。

3.当子类继承父类以后，可对父类中同名同参数的方法进行重写。则当子类的对象调用该方法时，实际上执行的是子类重写以后的方法。

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student(18,"张三");
        s1.show();
    }
}


class Person{
    private int age;
    private String name;


    public Person(){

    }

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public void show(){
        System.out.println("我是人");
    }

    public void eat(){
        System.out.println("人要吃饭");
    }
}

class Student extends Person{

    public Student(){
        super();
    }

    public Student(int age,String name){
        super(age,name);
    }

// 对父类的show()进行重写
    public void show(){
        System.out.println("我是一名学生");
    }

// 对父类的eat()进行重写
    public void eat(){
        System.out.println("学生要吃有营养的饭菜!");
    }
}

重写的原理:即为地址覆盖

③ Object类的理解:
Object类是所有类的父类，也可以说Object类是根类。即Java中除了Object类以外，其余的类都直接或间接的继承于Object。 如果一个类没有显示的继承某一个类的话，则这个类默认继承于Object类。

/*
	Person类没有显式的继承任何类。我们来看一看 它的父类是谁?
*/
public class Test {
    public static void main(String[] args) {
        // 显示Person类的父类。
        System.out.println(Person.class.getSuperclass());
    }
}


class Person{
    private int age;
    private String name;

    public void show(){

    }
}

程序运行结果：

(三) 多态性

① 多态性的定义: 父类的引用指向子类的对象。

② 多态的使用前提:
1).要有继承关系。
2).子类要重写父类的方法。
3).父类的引用指向子类的对象。

③ 使用多态:
1).有了对象的多态性以后，在编译期，只能调用父类中声明的方法，但是在运行期，则是调用了子类重写父类的同名方法。即虚拟方法调用。

2).虚拟方法:子类中定义了与父类同名同参的方法，在多态的情况下，此时父类中的该方法称为虚拟方法。父类根据不同的子类对象，动态的调用属于子类的该方法。

public class Test {
    public static void main(String[] args) {
        // 对象的多态性:  父类的引用指向子类的对象。
        Person p2 = new Man(); // 此时p2是Person类型的。
        
        // 多态的使用：当调用子父类同名同参数的方法时，实际执行的是 子类重写父类的方法 ---> 即虚拟方法调用。
        p2.eat();

        //p2.earnMoney();  这个编译报错。因为Person类中没有earnMoney()方法。
        
        //p2.dailyLife();  编译报错，因为p2声明为Person类型，但是Person类中没有dailyLife()这个方法。
    }
}





class Person {
    String name;
    int age;

    public Person(){
        System.out.println("我现在是人");
    }

    public void eat(){
        System.out.println("人吃饭");
    }

    public void walk(){
        System.out.println("人走路");
    }
}




class Man extends Person {
    boolean isSmoking;


    public Man(){
        System.out.println("我现在是男人");
    }

    public void earnMoney(){
        System.out.println("男人负责挣钱养家");
    }

    public void eat(){
        System.out.println("男人多吃肉");
    }
    
    public void dailyLife(){
        System.out.println("男人的日常生活....");
    }
}

④ 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法。
但是由于变量声明为父类类型，导致编译时，只能调用父类中的属性和方法，子类中特有的属性和方法不能调用。当我们使用了多态以后，如何调用子类中特有的方法呢？

向下转型

向下转型之前要使用instanceof关键字进行判断

    public static void main(String[] args) {
        Person p2 = new Man();
        
        if (p2 instanceof Man){
            Man m1 = (Man) p2;
            m1.dailyLife();
        }
    }

程序运行结果：