封装 继承 多态 重载 重写 抽象

java的四个基础特点：抽象 封装 继承 多态

一、属性的封装
1.将类中的数据【隐藏】   主要属性的访问权限进行控制
原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。   
public 任何对象可以访问   
private 只能在当前类中访问
protected当前类对象和子对象可以访问
如果属性加上了private修饰，那么这个属性在其他类中都无法访问
2.方法的封装：将类中方法的具体实现隐藏  为了提高代码的重用
3.私有属性怎么获得？
private int age;
//将私有属性封装进set方法。
public void setAge(int age) {
    this.age = age;
}
//通过get方法访问私有属性的值
public int getAge() {
    return age;
}

二、抽象
1.抽象的概念：一个类中没有包含足够的信息来描述一个具体的对象，这样的类就抽象类
用abstract修饰的类为抽象类
2.抽象类的特点：
（1）不能被实例化（不能被new 对象）
（2）抽象类不一定包含抽象方法，但一个类包含抽象方法，但它就一定是抽象类  
（3）抽象类中的抽象方法只是声明，不包含方法体。
（4）继承抽象类的子类如果不是抽象类必须重写父类的所有抽象方法
（5）构造方法，类方法（用static修饰的方法)不能被声明为抽象方法。
3.接口和抽象类的区别：
1）接口侧重于方法，抽象类侧重于属性。
2）接口  多继承  无构造器   只有抽象方法
3）抽象类 单继承 有构造器  可以有抽象方法和非抽象方法

相同点：都不能被实例化   都能包含抽象方法
接口详解：public interface A{}   继承接口关键字implements
接口中：成员变量  ：public static final类型   必须被显式初始化
              成员方法  ：没有方法体
                                默认是public abstract
 不能有任何形式的代码块
4.抽象类的非抽象方法怎么调用？
如果是staitc修饰的，直接用类名.方法名
如果是非static修饰的，必须要有一个继承的非抽象类，如果用子类的对象名.方法名调用。

三、继承：子类继承父类的特征和行为
1.单继承。
2.父类中什么会被继承：
1)父子类同包，子类继承父类中public、protected和默认修饰符可以继承。
2）不同包，默认修饰符不能被继承。
3）构造器不能被继承。
4）方法和实例变量可以被继承。
5）子类构造器隐式调用父类的无参构造器，如果父类中没有定义无参构造器，那么子类必须显示地调用有参的构造器。(通过super(...))
例：public class Animal(){
       private String name;
       public Animal(String name){this.name=name;}}
      public class Dog extends Animal(){
      public Dog(){super("小狗");}//显示地调用有参构造器
          }
6）this 和 super()在构造器中必须为第一条语句
7）构造子类的实例对象时，该对象包含了子类及父类的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。子类一定要访问父类的构造方法。
3.子类如何间接调用父类的私有方法？
父类的公有方法中，this.方法名调用父类的私有方法，然后子类对象调用这个公有方法就能访问到这个私有方法

4.子父类属性同名  如获取属性， 看对象是父类还是子类，子类对象看公有方法被调用的位置
9）子类私有方法与父类私有方法同名，如调用该方法，看私有方法被调用的位置，如在父类中，调用的是父类方法，如在子类中，调用的是子类方法；

public class Test2 {
public static void main(String[] args) throws Exception {
    new A().printPerson();//A
    new B().printPerson();//A  打印方法在父类中，调用的是父类方法
}
}
class A {
    public void printPerson() {System.out.println(getInfo());}
    private String getInfo() {return "A";}
}
class B extends A{
    public String getInfo() {return "B";}

}

 

public class test {
    public static void main(String[] args) throws Exception {
          new A().printPerson();//A
          new B().printPerson();//B
    }
}
class A {
    public void printPerson() {getInfo();}
    private void   getInfo() {
        System.out.println("A");
    }
}
class B extends A {
    @Override
    public void printPerson() {getInfo();}
    public void getInfo() {
        System.out.println("B");
    }
}

10）子类静态方法与父类静态方法同名，子类静态方法屏蔽父类静态方法。如调用该静态方法，看实例化对象时所声明的类型，如声明为父类，调用的是父类中静态方法，反之是子类中静态方法。（static 方法不能被重写）
。

四、重写
1.子父类中的方法完全一致。重写发生在子父类中。
2.特点：方法名、参数列表完全相同，异常不能放大，权限不能被缩小。（声明为 private 和 final 的方法不会被重写）

3.static修饰的方法不存在重写，子类可以定义与父类同名的静态方法.(不是覆盖）
4.父类中静态方法不能被子类覆盖为非静态方法
5.父类的非静态方法不能被子类覆盖为静态方法；
静态方法只与定义时的类有关，静态方法在类被装载时已经被加载
6,抽象方法：
      a. 父类的抽象方法可以被子类覆盖为非抽象方法： 子类实现父类抽象方法；
      b. 父类的抽象方法可以被子类覆盖为抽象方法：   重新声明父类的抽象方法；
      c. 父类的非抽象方法不可以被子类覆盖为抽象方法；（权限不能被缩小）


五、重载
同一个类中，方法名相同，参数列表不同  不讨论返回值的多个方法，叫方法的重载。
好处: 给用户对功能的调用和使用提供了很大的灵活性

六多态
同一个行为具有不同的表现形式
多态存在的三个必要条件：1继承2重写3父类的引用指向子类型的对象
父类的引用指向子类的对象

多态出现在 具有继承关系的两个类对象之间，
    语法: 父类 变量名 = new 子类();
             接口 变量名 = new 实现类();父接口的引用指向实现类的对象

 使用多态的对象调用方法时:
        编译: 看父类中是否有这个方法/接口中是否有这个方法
        运行: 执行具体实现类中的方法

多态的好处：一个引用变量到底指向哪个类的实例对象 只有程序运行期才能决定
可以引用父类的共性，和子类的重写方法

缺点：无法调用只存在子类的属性 方法