目录
一、封装
所谓封装就是将对象的属性隐藏起来,不让外界直接访问,而是通过指定的方法来访问对象的属性,就叫封装。Java 中封装是面向对象三大特征之一,它的作用就是让程序的安全性得以提高。
1.1 封装的意义
我们通过下面的示例来说明这个问题。
我们创建一个 Human 类,在这个类中定义两个属性,一个姓名,一个年龄。
class Human {
String name;
private int age;
public void setAge(int newAge) {
age = newAge;
}
public int getAge() {
return age;
}
}
public class HumanTest {
public static void main(String[] args) {
Human human = new Human();
human.name = "张三";
//human.age = -18;
human.setAge(18);
System.out.println(human.name + " " + human.getAge());
}
}
通过上面的示例演示,如果我们不把 age 属性隐藏起来,那么在外部(HumanTest类中的 main 方法中)就可以直接对这个属性进行赋值。这就会产生不确定的因素,如给年龄一个负数或都一个很大的数。这些情况都是不对的。为了避免这种情况的发生,我们需要把这个属性进行隐藏,从而提高程序的健康性。
1.2 如何进行封装
在 Java 中需要使用 private 关键字来修饰要被隐藏的属性。然后提供这个属性对应的两个公共方法:一个用于对这个属性进行赋值,另一个用于对这个属性进行获取值。
class Human {
String name;
private int age;
public void setAge(int newAge) {
age = newAge;
}
public int getAge() {
return age;
}
}
例如上面代码中的 setAge(int newAge) 和 getAge() 这两个方法都是封装方法。一般来说,给属性赋值的方法取名为 setXXX,而获取属性值的方法取名为 getXXX。其中XXX 表示属性的名称,该名称的首字母大写。
注意:为了安全性,在写实体类中,只要有属性存在都需要进行封装。
二、继承
继承是面向对象程序设计的第二个特征,为了提高代码的复用率,继承应运而生。
2.1 继承的意义
我们通过如下的案例来说明这个问题。
class Woman {
public String name;
public int age;
public void show() {
System.out.println(name + " " + age);
}
}
class Man {
public String name;
public int age;
public void show() {
System.out.println(name + " " + age);
}
}
public class PersonDemo {
public static void main(String[] args) {
Man man = new Man();
man.name="张三";
man.age=18;
man.show();
Woman woman = new Woman();
woman.name = "李四";
woman.age=19;
woman.show();
}
}
从上面的代码中可以发现,现个类中除了类名不同以外,其余的代码都是相同的。这样的话代码复用率就不高。为了让代码的复用率更高。我们可以把两个 类中相同的代码提取出来形成一个单独的类,然后让这两个类去继承它即可。
2.2 如何继承
首先我们需要定义一个父类,在这个父类中定义公共的属性或方法。例如上面的示例中我们可以定义一个父类如:Person,然后在这个父类中定义公共的属性和方法。
class Person {
public String name;
public int age;
public void show() {
System.out.println(name + " " + age);
}
}
class Woman extends Person {
}
class Man extends Person {
}
public class PersonDemo {
public static void main(String[] args) {
Man man = new Man();
man.name="张三";
man.age=18;
man.show();
Woman woman = new Woman();
woman.name = "李四";
woman.age=19;
woman.show();
}
}
子类需要使用 extends 关键字来继承父类。通过这样的操作后,Person类中父类或者叫基类,而Man和 Woman 叫子类或者派生类。
2.3 继承的优点
-
提高了代码的复用率
-
它是多态前提条件
2.4 继承的缺点
-
父类中私有的属性和方法,子类是无法使用的
-
在java中只支持单继承,不支持多继承,但是可以支持多重继承
-
继承后子父类的关系就接合得非常的紧密,不利于程序的扩展,从而减少了程序的灵活性。
-
父类无法访问子类的属性和方法
三、多态
3.1 多态的定义
一个对象在不同条件下表示的不同形态就叫多态,在程序中,多态是父类引用指定子类对象。
// 多态
class Father {
String name;
public void desc() {
System.out.println("----------");
System.out.println(name + "小头爸爸");
}
}
class Son extends Father {
String name;
public void desc() {
System.out.println("+++++++++++++");
System.out.println(name + "大头儿子");
}
}
public class PolymorphicDemo1 {
public static void main(String[] args) {
Father father = new Son();
father.name = "大头儿子";
father.desc();
}
}
另一种多态的使用方式是在方法的参数上,一般我们在使用工厂设计模式时会使用多态 。
//
abstract class Animal {
abstract void haha();
}
class Cat extends Animal {
@Override
void haha() {
System.out.println("Cat haha()");
}
}
class Dog extends Animal {
@Override
void haha() {
System.out.println("Dog haha()");
}
}
class HelloKit {
public static Animal create(Animal animal) {
if (animal instanceof Cat) {
return new Cat();
}else if (animal instanceof Dog) {
return new Dog();
} else {
return null;
}
}
}
public class HelloKitDemo {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Animal animal = HelloKit.create(cat);
animal.haha();
Animal animal1 = HelloKit.create(dog);
animal1.haha();
}
}
在参数列表上,使用父类去接收,也是一种多态的使用方式。
3.2 多态的使用要求
1,在多态的情况下,不能使用子类特有的方法
class Person {
public int age = 5;
public void show() {
System.out.println("Person age: " + age);
}
}
class Student extends Person {
public int age = 10;
public String name = "小明";
public void show() {
System.out.println("Student age: " + age);
}
public void speak() {
System.out.println(name);
}
}
public class PolymorphicDemo2 {
public static void main(String[] args) {
Person p = new Student();
p.show(); // 可以执行
p.speak(); // 报错,因为 speak 方法是子类特有的方法
}
}
2,多态在例子中如果属性是非静态的,它的值是看等号左边
// 多态的注意事项
class Person {
public int age = 5;
public void show() {
System.out.println("Person age: " + age);
}
}
class Student extends Person {
public int age = 10;
public String name = "小明";
public void show() {
System.out.println("Student age: " + age);
}
public void speak() {
System.out.println(name);
}
}
public class PolymorphicDemo2 {
public static void main(String[] args) {
Person p = new Student();
System.out.println(p.age); // 5 ,是不是 10
}
}
原因:我们使用的是多态,也就是说我们输出的 p.age
,而 p 是父为的引用,它获取到的值就是父类中定义的值。
在多态下,编译是看等号的左边,运行时如果是属性则看等号左边。
3,在多态下的非静态方法
// 多态的注意事项
class Person {
public int age = 5;
public void show() {
System.out.println("Person age: " + age);
}
}
class Student extends Person {
public int age = 10;
public String name = "小明";
public void show() {
System.out.println("Student age: " + age);
}
}
public class PolymorphicDemo2 {
public static void main(String[] args) {
Person p = new Student();
p.show();
}
}
在多态下,编译是看等号的左边,运行时如果方法是非静态的看等号的右边。
4,在多态下的静态成员
// 多态的注意事项
class Person {
public static void x() {
System.out.println("Person static x");
}
}
class Student extends Person {
public static void x() {
System.out.println("Student static x");
}
}
public class PolymorphicDemo2 {
public static void main(String[] args) {
Person p = new Student();
p.x(); // Person static x
}
}
在多态下,静态的成员在编译和运行时都看等号的左边。