Java学习–面向对象

构造器

1. 和类名相同
2. 没有返回值
3. 作用：new本质实在调用构造器，构造器就是初始化对象的值
4. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造；

三大特性

1. 封装
程序设计追求“高内聚，低耦合”。高内聚就是类的内部数据细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给内部使用。
通常，应禁止访问一个对象中数据的实际表示，而是通过操作接口来访问，称为封装。
封装核心：private get，set方法
意义:1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
示例：
2. 继承
在Java中，所有的类，都默认或间接继承Object，Java中只有单继承没有多继承

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能出现在子类的方法或者构造方法中。
3. super和this不能同时调用构造方法。

VS this：

1. 代表对象不同：
   this：本身调用者这个对象
   super：代表父类对象的应用
2. 使用前提不同
   this：没有继承也可以使用
   super：只能在继承条件下才可以使用
3. 构造方法
   this（）；本类的构造
   super（）；父类的构造

方法重写：
需要有继承关系，子类重写父类的方法，方法体不同。

1. 方法名必须相同
2. 参数列表相同
3. 修饰符：范围可以扩大但不能缩小： public>protected>Default>private
4. 抛出异常：范围可以被缩小但不能扩大：ClassNotFoundException–>Exception(大)

为什么需要重写：
父类的功能，子类不一定能够满足或不一定需要

Alt+Insert：override；快捷键
3. 多态
多态是同一方法可以根据发送对象的不同而采取多种不同的行为方式。调用的方法并不是在编译期决定的，而是根据运行时实际引用的对象类型来决定真实调用的方法

1. 多态是方法的多态，不是属性的多态
2. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father lic = new Son();
3. 不能重写：
   static 方法：属于类，不属于实例
   final 常量；
   private方法；
   

instanceof和类型转换

      Object object = new B();
        //System.out.println(X instanceof  Y);判断有没有父子关系
        System.out.println(object instanceof B);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof A);//true
        System.out.println(object instanceof String);//false
        A a1 = new B();
        System.out.println(a1 instanceof B);//true
        System.out.println(a1 instanceof Object);//true
        System.out.println(a1 instanceof A);//true
       // System.out.println(a1 instanceof String); 编译出错

向上转型（低转高）：子类转换成父类，可能为丢失子类本身的方法
向下转型（高转低）：父类转换成子类，强制转换

       //高            低
        A father = new B();
        B son = (B) father;
        ((B) father).eat(); //强制转换 父类转换成子类

抽象类

1. 不能new抽象类，只能靠子类实现它，是单继承
2. 抽象类里有普通方法，构造方法
3. 抽象方法必须在抽象类中
4. 意义：提出框架，提高开发效率，把方法抽象出来

public abstract class Demo03 {

    public abstract void aVoid();//抽象方法
    public void bVoid(){};//普通方法
    public Demo03() {}//构造方法

}
class Demo04 extends Demo03{

    @Override
    public void aVoid() {
        System.out.println("继承抽象类并实现抽象方法");
    }
}

接口

接口就是规范，定义的一组规则，oop的精髓就是对对象的抽象，最能体现这一点的就是接口。

1. 声明接口的关键字是interface；接口里面定义的方法都是public abstract；定义的属性都是常量 public static final
2. 接口不能被实例化，没有构造方法
3. implements可以实现多个接口
4. 必须要重写接口中的抽象方法

//接口只有方法的定义
public interface Demo05 {
    void aVoid(String str);
    void bVoid();
}
interface Demo06{
    int aInt(int a);
    int bInt();
}
//利用接口实现多继承
class Demo56imp implements Demo05,Demo06{
    @Override
    public void aVoid(String str) {

    }

    @Override
    public void bVoid() {

    }

    @Override
    public int aInt(int a) {
        return 0;
    }

    @Override
    public int bInt() {
        return 0;
    }
}

N种内部类

1. 外部类
2. 内部类
3. 局部内部类 （类中的方法再写类）
4. 匿名内部类 （就是没有名字的内部类）

public class Outer {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); //通过外部类实例化内部类
        //匿名内部类
        System.out.println(new One().anInt);
        new Two() {
            @Override
            public void aVoid() {

            }

            @Override
            public void bVoid(String str) {

            }
        };
    }
   private int id = 100;
   public void aVoid(){
       System.out.println("外部类");

   }
    public void method(){
        class InnerJu{
            public void in(){
                System.out.println("局部内部类");
            }
        }

    }
   class Inner{
       public void bVoid(){
           System.out.println("内部类");
       }
       //获得外部类的私有属性
       public void getID(){
           System.out.println(id);
       }
   }
}
class One{
    int anInt = 90;
    public void aVoid() {}
}
interface Two{
    void aVoid();
    void bVoid(String str);
}

new接口时必须把抽象方法全部实现。