java-6

1.封装：

将方法的实现细节进行隐藏，同时提供对外访问接口，常见的将方法封装在类中就是封装的一种体现。

2.private修饰词

private修饰词，私有化，被修饰的变量、方法只能在当前类内访问，无法被继承，方法只能在该类内使用，如果其他类要访问这些变量，就要在

当前类内提供访问的方法，这种做法也是封装的一种体现。

public class Student {
    private String name;
    private int age;
    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;
    }
}

3.this关键字

this关键字可以粗略的理解为当前的意思:

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

该方法需要一个实例化的Student对象来调用，this指的就是当前的调用对象，可以理解为 调用对象.name = 形参的name

局部变量与成员变量重名问题：

public void speak() {
        //int age = 20;
        //String name = "张三";
        System.out.println(this.name+this.age+this.sex);
        //局部变量与对象成员变量重名时：
        //如果没有如上两个局部变量，则可以不加this，调用对象的对应的成员变量；
        //如果有局部变量，而不加this，会就近调用局部变量，如果加了this，则访问调用对象的对应成员变量
}

 4.继承

指的是在一个现有的类的基础上再创建一个子类，子类继承父类的所有属性与方法，同时子类可以拥有自己独有的属性和方法

class Father{
  String lastname;
  double race；
  public void walk(){
       System.out.print("行走");
  }  
}


class Son extends Father{
   String firstname;
   public void run(){
       System.out.print("奔跑");
   }
}

 多重继承：

一个子类只能直接拥有一个父类，但可以间接拥有另外一个父类

public class Animals { //父类
    String race;
    public void see() {
        System.out.println("看见");
    }
}

public class Dog extends Animals{  //父类，同时也是Animals的子类
    String color;
    int yp;
    String sex;
}

public class Hdog extends Dog{  //子类 是Dog的子类，同时也是Animals的子类
    String per;
}

继承问题：

父类中被private修饰的成员变量、方法无法被子类继承！

5.super关键字

类似于this，super可以被粗略的被认为是当前的父级

public class Dog extends Animals{  
    String color;
    int yp;
    String sex;
}
public class Hdog extends Dog{  
    String per;
    public void test() {
        System.out.println(this.color); //调用当前类成员变量
        System.out.println(super.color);//super 调用父类成员变量;
    }
}

构造方法中：

public class Dog extends Animals{  //父类
    String color;
    int yp;
    String sex;
    public Dog(String color,int yp,String sex) {
        this.color = color;
        this.yp = yp;
        this.sex = sex;
    }
}
public Hdog(String color,int yp,String sex,String per) {
        super(color,yp,sex);//方法重载，调用父类构造方法
      this.per =per;
}
注意，由于此处的父类没有默认的无参构造方法，而子类会默认调用父类的无参构造方法，所以子类必须重写一个有参构造方法！

6.方法重写

子类会继承父类的方法，如果子类向利用该方法来提供不同的效果，就要重写该方法。

public class Dog extends Animals{  
    String color;
    int yp;
    String sex;
    public Dog(String color,int yp,String sex) {
        this.color = color;
        this.yp = yp;
        this.sex = sex;
    }
        public void sleep() {
        System.out.println("睡觉");
    }
    public static void spark() {
        System.out.println("狗叫");
    }
}    

public class Hdog extends Dog{ 
    String per;
    public Hdog(String color,int yp,String sex,String per) {
        super(color,yp,sex);
        this.per =per;
    }
        public void sleep() {
        System.out.println("躺着睡觉");//重写
    }
    public static void spark() {
        System.out.println("二哈叫");//隐藏，重写父类类方法
    }
}
方法调用时，当Dog的对象调用sleep方法时，输出睡觉，而Hdog的对象调用sleep时输出躺着睡觉，同理，类方法的隐藏也是如此
注意，子类“重写”父类类方法表面看起来是在重写，实际上是重新定义了一个方法名与父类方法名相同的类方法，
只不过用各自的类、对象去调用类方法时会调用各自的类方法，可以理解为子类屏蔽了继承自父类的类方法。
注意，子类继承的方法在重写时，其修饰词权限要大于等于父类方法
修饰词作用域大小：public protected default(默认值，不写！) private