java入门(二)_面向对象的三大性

目录

 

一、封装性

二、继承性

1、继承的特性： 

2、构造器

三、多态性

---

一、封装性

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。封装的优点：良好的封装能够减少耦合、类内部的结构可以自由修改、可以对成员变量进行更精确的控制、隐藏信息，实现细节。

class Person {
	private int age;
	private String  name;

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

	public void setName(String  name) {
		this.name = name;
	}

	public int getAge() {
		return  age;
	}

	public String  getName() {
		return  name;
	}

}

public class Encap {
	public static void  main(String args[]) {
		Person  per_1 = new Person();
		per_1.setName("xaiowu");
		per_1.setAge(24);
		System.out.println("name: "+per_1.getName()+";  "+"age: "+per_1.getAge());
	}
};

编译结果：

name: xaiowu;  age: 24

二、继承性

1、继承的特性： 

• 子类拥有父类非 private 的属性；
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；
• 子类可以用自己的方式实现父类的方法；
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类

class Animal {
        void eat() {
                System.out.println("animal : eat");
        }

        final void name() {
                System.out.println("I am just an animal");
        }
}

class Dog extends Animal {
        void eat() {
                System.out.println("dog : eat");
        }

        void eatTest() {
                this.eat();   // this 调用自己的方法
                super.eat();  // super 调用父类方法
        }
}

public class EnTest {
        public static void main(String[] args) {
                Animal a = new Animal();
                a.eat();
                Dog d = new Dog();
                d.eatTest();
                d.name();
         }
}

编译结果：
animal : eat
dog : eat
animal : eat
I am just an animal

提示：

• super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
• this关键字：指向自己的引用。
• final关键字：声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写，实例变量也可以被定义为 final，被定义为 final 的变量不能被修改，被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final。

2、构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;

  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }

  public SubClass(int n){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}

public class TestSuperSub{
  public static void main (String args[]){
         System.out.println("------SubClass 类继承------");
         SubClass sc1 = new SubClass();
         SubClass sc2 = new SubClass(100);
   }
}

编译结果：
------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
 

三、多态性

多态是同一个行为具有多个不同表现形式或形态的能力。

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("看家");  
    }  
}

编译结果：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠