本文共 7063 字，大约阅读时间需要 23 分钟。

一、封装

1、封装含义

所谓类的封装是指在定义一个类时，将类中的属性私有化，即用private关键字来修饰，为了能让外界访问私有属性，需要提供一些public修饰的公共方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。

举例：

import java.util.*;class Student {
       private String name;    private String sex;    private int age;    //下面是公有的getXxx()和setXxx()方法    public String getName() {
           return name;    }    public void setName(String name) {
           this.name = name;    }    public int getAge() {
           return age;    }    public void setAge(int age) {
           this.age = age;    }    public String getSex() {
           return sex;    }    public void setSex(String sex) {
           this.sex = sex;    }    public void introduce(){
           //打印属性name和age的值        System.out.println( name +"是男生"+age +"岁！");    }}public  class TestDemo {
       public static void main(String args[]) {
           Student per = new Student();// 声明并实例化对象        Student stu = new Student(); //创建学生对象        stu.setName("张三"); //利用set方法为name属性赋值        stu.setAge(18);  //利用set方法为age属性赋值        System.out.println(stu.getName());//利用get方法获取Name的值        System.out.println(stu.getAge());//利用get方法获取Age的值        //调用对象的introduce()方法        stu.introduce();    }}

运行结果：

张三18张三是男生18岁！Process finished with exit code 0

2.四种权限访问修饰符

封装性的体现，需要权限修饰符来配合。

1. Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
2. 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
   具体权限如下：
   
   拓展（缺省定义方式）：

class TestDemo {
       //“缺省”修饰的方法    void test(){
           System.out.println("hello world");    }    public static void main(String[] args) {
           TestDemo dt =new TestDemo();        dt.test();    }}

二、继承

1.继承的概念

继承的主要作用在于，在已有基础上继续进行功能的扩充。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

2.类的继承格式

类的继承格式class 父类 {
   } class 子类 extends 父类 {
   }

3.继承的好处

1. 继承的出现减少了代码冗余，提高了代码的复用性。
2. 继承的出现，更有利于功能的扩展。
3. 继承的出现让类与类之间产生了关系，提供了多态的前提
   我们可以通过下面一段代码来深入理解:

package study.day_11;class Person1 {
      String name;   int age;   public Person1() {
      }   public Person1(String name, int age) {
          this.name = name;       this.age = age;   }   public  void eat(){
          System.out.println("吃饭");   }   public void sleep(){
          System.out.println("睡觉");   }}class Student1 {
      String name;   int age;   String major;   public Student1(){
      }   public Student1(String name, int age, String major) {
          this.name = name;       this.age = age;       this.major = major;   }       public  void eat(){
          System.out.println("吃饭");   }   public  void sleep(){
          System.out.println("睡觉");   }   public  void study(){
          System.out.println("学习 ");   }}public class Person{
      public static void main(String[] args) {
      }}

从以上可看出，含有大量重复的代码，java语言一般不允许大量重复的代码出现，这段代码不仅从代码上重复，而且从概念上讲学生一定是人，只是学生类描述的范围小，具备更多的属性和方法，这个时候想要消除结构定义上的重复，就要用到继承。

所以可将上述代码改为：

class Person1 {
       String name;    int age;    public Person1() {
       }    public Person1(String name, int age) {
           this.name = name;        this.age = age;    }    public  void eat(){
           System.out.println("吃饭");    }    public void sleep(){
           System.out.println("睡觉");    }}class Student1 extends Person1{
       String major;//专业    public Student1(){
       }    public Student1(String name, int age, String major) {
           this.name = name;        this.age = age;        this.major = major;    }    public  void study(){
           System.out.println("学习 ");    }}public class TestDemo{
       public static void main(String[] args) {
           System.out.println("Student类*************");        Student1 s1=new Student1();        s1.name="张三";        s1.age=18;        s1.major="Java语言";        System.out.println("姓名："+s1.name+"年龄："+s1.age+"专业："+s1.major);    }}

运行结果：

Student类*************姓名：张三年龄：18专业：Java语言Process finished with exit code 0

4.继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，每个子类只有一个父类。
• 子类直接继承的父类，称为：直接父类，间接继承的父类称为：间接父类。子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

5.继承关键字

（1）super 关键字

super关键字的使用：

1.super理解为：父类的

2.super可以用来调用：属性、方法、构造器

格式：

1.我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

2.特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。 3.特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

super调用构造器

1.我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

2 ."super(形参列表)"的使用，必须声明在子类构造器的首行！ 3.我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现 4. 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super() 5.在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器 举例：

class people {
       void eat() {
           System.out.println("人吃饭");    }}class Men extends people {
       void eat() {
           System.out.println("张三吃饭");    }    void eatTest() {
           this.eat();   // this 调用自己的方法        super.eat();  // super 调用父类方法    }}public class TestDemo11_4 {
       public static void main(String[] args) {
           people a = new people();        a.eat();//打印people父类中eat方法        Men d = new Men();        d.eatTest();//打印子类Men中eatTest方法    }}

运行结果：

人吃饭张三吃饭人吃饭

（2）final关键字

final 关键字声明类可以把类定义为不能继承的；或者用于修饰方法，该方法不能被子类重写

*声明类：final class 类名 {
   //类体}

*声明方法：修饰符(public/private/default/protected) final 返回值类型 方法名(){
   //方法体};

三、多态

1.什么是多态

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

多态就是同一个接口，使用不同的实例而执行不同操作。 打印这个行为具有彩色打印和黑白打印两种不同的表现形式。

2.多态的使用

1.对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

2. 多态的使用：虚拟方法调用：

• 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
• 总结：编译，看左边；运行，看右边。

3.多态性的使用前提： ① 类的继承关系 ② 方法的重写

4. 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

以下是一个多态实例的演示，详细说明请看注释：

Person类：

package study.day_13.java;public class Person {
      String name;   int age;      int id = 1001;      public void eat(){
      	System.out.println("人：吃饭");   }      public void walk(){
      	System.out.println("人：走路");   }   }

Man类：

package study.day_13.java;public class Man extends Person{
   		boolean isSmoking;		int id = 1002;		public void earnMoney(){
   		System.out.println("男人负责挣钱养家");	}		public void eat(){
   		System.out.println("男人多吃肉，长肌肉");	}		public void walk(){
   		System.out.println("男人霸气的走路");	}}

Woman类：

package study.day_13.java;public class Woman extends Person{
   		boolean isBeauty;		public void goShopping(){
   		System.out.println("女人喜欢购物");	}		public void eat(){
   		System.out.println("女人少吃，为了减肥");	}		public void walk(){
   		System.out.println("女人窈窕的走路");	}}

测试类：

public class PersonTest {
   	public static void main(String[] args) {
   		System.out.println("Person类eat方法**********");		Person p1 = new Person();		p1.eat();		System.out.println("Man类方法*************");		Man man = new Man();		man.eat();		man.earnMoney();				//*************************************************		System.out.println("多态*******************");		//多态：子类的对象赋给父类的引用（父类的引用指向子类的对象）		Person p2 = new Man();		//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用		p2.eat();		p2.walk();		/**		 *p2.earnMoney();		 *有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型		 * 编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。		 **/	}}

运行结果：

Person类eat方法**********人：吃饭Man类方法*************男人多吃肉，长肌肉男人负责挣钱养家多态*******************男人多吃肉，长肌肉男人霸气的走路

转载地址：http://terpi.baihongyu.com/