java三大特性

前言

java3大特性,封装,继承,多态,简单理解,封装用来隐藏信息,继承是一个类继承另一个类,多态就是表现的行为方法的不同。

封装

封装是面向对象方法的重要原则,就是把对象的属性和操作,尽可能的隐藏对象内部的实现细节。

优点:
  1. 内部类可以自由修改
  2. 隐藏信息,实现细节
  3. 对成员可以更精确的控制
  4. 减少耦合

例子:

package javatest;

public class one1 {
public static void main(String[] args) {
Person onePerson = new Person();
onePerson.setName("zerobs");
onePerson.setAge(19);
onePerson.getName();
onePerson.getAge();
}
}
class Person{
private String name;
private int age;
public void getName() { 
    System.out.println("my name is "+name);
}
public void setName(String name) {
    this.name = name;
}
public void getAge() {
    System.out.println("i am "+age+"years old");
}
public void setAge(int age){
    this.age = age;
}

}输出:

my name is zerobs
i am 19years old

使用的private方法,只有本类才可以访问,这里提供getter给外部访问,可以看到使用封装减少了许多操作,对象内部的成员赋值使用setter,访问getter即可。

继承

继承是最能体现面向对象的一个特性,继承是在已有的类中派生一个新的类,这个类可以继承父类的属性和行为,并且拥有改写和扩展的能力。其次,继承是多态的基础。

类的继承:

package javatest;


public class two1 {
    public static void main(String[] args) {
        bat cat1 = new bat("cat1", 1);
        cat1.getAd();
        cat1.getName();
        cat1.eat();
        bog dog1 = new bog("dog1", 2);
        dog1.getAd();
        dog1.getName();
        dog1.eat();
    }
}

class Animal1{
    private String name;
    private int ad;
    public Animal1(String name,int ad) {
        // TODO Auto-generated constructor stub
        this.name = name ;
        this.ad = ad;
    }
    public void getName() {
        System.out.println("my name is "+name);
    }
    public void getAd() {
        System.out.println("my ad is "+ad);
    }
}

class bat extends Animal1{
    public bat(String name,int ad) {
        super(name, ad);
    }
    public void eat(){
        System.out.println("i like eat fish");
    }
}

class bog extends Animal1{
    public  bog(String name,int ad) {
        super(name, ad);
    }
    public void eat(){
        System.out.println("i like eat bone");
    }
}

输出:

my ad is 1
my name is cat1
i like eat fish
my ad is 2
my name is dog1
i like eat bone

可以看到有继承之后,super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类,对同类型有相同方法的类就免去了重新写的麻烦,在子类中也可以继承父类的方法,也可以扩展父类的方法,当然还有重写的能力。

继承的特点:
  1. 继承父类非private的属性,方法
  2. 可以拥有自己的方法和属性
  3. 可以重新父类
  4. 可以单继承,多重继承,但是不需要多继承
  5. java中所有的类都继承于java.lang.Object
  6. final关键字申明的类不可继承
注意:

继承中子类是不继承父类的构造方法的,但是可以调用,分为隐式和显式,有参数则通过显式supper关键字调用父类的构造方法,如果没有参数,则可以不用super调用父类的构造器。

多态

多态是对象多种表现形式的体现

优点
  1. 消除类型间的耦合
  2. 接口性
  3. 灵活性
  4. 简化性
  5. 可替换性
  6. 可扩充性
必要条件
  1. 继承
  2. 重写
  3. 父类引用指向子类对象

菜鸟教程上的一个例子:

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
            
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
        
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

抽象类中的所有抽象方法都必须实现,如果没有全部重写,那么子类也是抽象类,并且抽象类不可以被实例化,一个类只能继承一个一个抽象类,但是可以继承多个接口

Last modification:December 4th, 2020 at 12:31 am