学步园

一、封装

 　　功能：其实就是实现代码的复用，屏蔽一些细节

　　　　比如下面这个例子：   我在类Person里面封装了一个方法public void pname（）｛｝这样的话在main方法里面就不用重复使用System.out.println();这句话了，避免了代码的重复使用，成程序看起来比较简洁

public class test{
  public static void main(String agrs[]){
      Person p1 = new Person();
      p1.name = "jack1";
      Person p2 = new Person();
      p2.name = "jack2";
      Person p3 = new Person();
      p3.name = "jack3";
      Person p4 = new Person();
      p4.name = "jack4";
      
      p1.pname(p1);
      p2.pname(p2);
      p3.pname(p3);
    p4.pname(p4);
  }
}

class Person{
  String name;
  public void pname(Person person){
    System.out.println(person.name);
  }
}

 

二、继承

　　概念：就是指对象与对象之间的一种关系

　　作用：代码的复用、功能的扩展

　　在JAVA中使用extends关键字来表示两个类的继承，当子类继承了一个父类（基类、超类）的时候，子类自动拥有父类的所有成员。

　　1、方法的重写（voerread）

　　　　是发生在继承关系中的，在父类中被重写的方法和子类中重写的方法必须有相同的方法名、相同的返回值类型、相同的参数列表，子类中重写的方法不能拥有比父类中更加严格的访问修饰符

　　　　例如下面这个简单的例子：

　　　　　　　　

public class test{
   　　　　　　　　 public static void main(String[] args){
        
       　　　　　　　　 Animel animel = new Animel();
       　　　　　　　　 animel.name = "mouse";
       　　　　　　　　 animel.age = "12";    
       　　　　　　　　 animel.named();    
      　　　　　　　　  Cat cat = new Cat();
       　　　　　　　　 cat.name = "cat";
       　　　　　　　　 cat.age = "13";
       　　　　　　　　 cat.sex = "boy";
       　　　　　　　　 cat.named();
        
  　　　　　　　　  }
　　　　　　　　}
　　　　　　　　class Animal{
    　　　　　　　　String name;
    　　　　　　　　String age;
    　　　　　　　　public void named(){
        　　　　　　　　System.out.println("name is:" + name + "it is age is :" + age);
    　　　　　　　　}
　　　　　　　　}

　　　　　　　　class Cat extends Animal{
    　　　　　　　　String sex;
   　　　　　　　　 public void named(){
        　　　　　　　　System.out.println("name is:" + name + "it is age is :" + age + "sex is " + sex);
   　　　　　　　　 }
　　　　　　　　}

 

　　2、方法的重载（overload）

　　　　发生在同一个类当中，必须拥有相同的方法名，可以拥有不同的返回值类型，但是必须拥有不通的参数列表

　　　　比如下面这个简单的例子加以理解：

　　　　　　

public class test{
    　　　　　　public static void main(String args[]){
       　　　　　　 Numbsum bsum = new Numbsum();
        　　　　　　bsum.sum(20);
        　　　　　　bsum.sum(20,30);
        　　　　　　bsum.sum(20,30,40);
    　　　　　　}
　　　　　　}

　　　　　　class Numbsum{
    　　　　　　public void sum(int a){
       　　　　　　 System.out.println(a);
    　　　　　　}
   　　　　　　 public void sum(int a,int b){
       　　　　　　 System.out.println(a+b);
   　　　　　　 }
   　　　　　　 public void sum(int a,int b,int c){
        　　　　　　System.out.println(a+b+c);
    　　　　　　}
　　　　　　}

 

 

　　3、Super关键字

　　　　相当于当前父类对象的引用，每一个子类的对象中都有父类的对象，因为子类自动拥有父类的所有成员；JAVA在构建子类的对象的过程中，要先构建父类的对象，然后再创建子类的对象。

　　　　下面这个框架图把这个抽象的概念形象化的表示出来了：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图  1

　　　　注意：1）、当子类的成员变量和父类的成员变量重名时，需要访问父类的成员变量的时候使用  super.成员变量名   来调用

　　　　　　　2）、重写的过程中，子类重写的方法需要调用父类被重写的方法的时候使用  super.方法名

　　　　　　　3）、如果父类中没有无参数的构造方法时，是不能成功创建子类的对象的，需要在子类构造方法中手动添加父类的构造方法 super.() 

　　　　　　　　如下简单程序代码说明其原理：

public class test{
    public static void main(String[] args){
        Student person = new Student();

    }
}

class Person{
    public Person(int num){
    
    }
}

class Student extends Person{
    public Student(){
        super(100);
        System.out.println("子类对象成功创建");
    }
}

 

　　　　注意：继承中子类创建对象的一些细节过程

　　　　　　  1）、先创建父类对象再创建子类对象

　　　　　　  2）、JAVA是用构造方法来创建对象的

　　　　　　 3）、JAVA要先调用父类的构造方法，再调用子类的构造方法

　　　　　　 4）、JAVA默认调用父类中无参的构造方法

　　　　　　 5）、给父类中添加了一个有参数的显示的构造方法，那么隐式的无参数的构造方法就不存在了

 

三、多态

　　根据程序执行的时候根据传入的参数决定绑定哪一个方法

　　条件：1、要有继承   2、方法的重写   3、父类的引用指向子类的对象