面向对象

面向对象

• 物以类聚,分类的思想, 思考解决问题需要哪些分类,对这些分类单独思考

  以类的方式组织代码,以对象的组织(封装)数据

• 对于描述复杂的事物,为了从宏观上把握,从整体分析,需要使用面向对象的思想分析整个系统,

  但是,具体到微观操作,仍然需要面向过程的思路去处理

• 抽象:

  从认识论的角度考虑, 先有对象(具体的事物)后有类(对象的抽象)

  从代码运行的角度,先有类后有对象,类是对象的模板

• 三大特性

  • 封装

    高内聚,低耦合

    数据隐藏:禁止直接访问对象中数据的实际表示 而是通过操作接口实现(属性私有 get/set)

  • 继承

    • super构造方法如果出现在子类中,必须是构造方法且是第一句

    • 方法重写(方法签名相同,修饰符范围可以扩大,抛出异常范围可以缩小)

      static,final,private不能被重写

      静态方法(非重写,只是存在两个方法签名相同的方法): 会调用声明的类方法 如B b=new A(); 其中B继承A 则实际调用的是B的静态方法

      普通方法: 会调用实际对象的方法 如B b=new A(); 其中B继承A 则实际调用的是A的对象方法

  • 多态

    • 同一个方法可以根据对象类型不同而采用不同的行为方式

    • 多态是方法的多态,属性没有多态

    • 父类引用指向子类对象,只能调用父类共有的方法,不能调用子类独有的方法;若调用重写方法,实际调用子类方法

• instanceof

  x instanceof Y会先判断x声明的类型是不是可能是Y 或者Y 的子类,一定不是则编译报错,否则运行时判断实际类型.

  将父类转化为子类前需要进行类型检测,防止ClassCastException

• static

  
  //2.每次生成对象后执行,一般用于赋初值
  {
      System.out.println("匿名代码块");
  }
  ​
  //1.随类加载执行,只执行一次
  static {
      System.out.println("静态代码块");
  }
  ​
  //3
  public HelloWorld(){
      System.out.println("构造代码块");
  }

  //静态导入包

  import static

• 抽象类 abstract

  无法实例化,可采用匿名继承实现其抽象方法

  
  public abstract class ClassD {
      public abstract void run();
  ​
      public  void eat(){
          System.out.println("eat");
      }
  }

  
   ClassD cl=new ClassD(){
              public  void run(){
                  System.out.println("run");
              }
          };
         cl.run();
         cl.eat();

  抽象类无法实例化,但可以有构造方法,其构造器会在子类实例化时调用 .

• 接口 (规范和契约)

  没有构造方法

  方法默认public abstract

  字段默认public static final

• 内部类

  定义在一个类内部的类

  • 成员内部类

    
    public class Outer {
        private int id=10;
        public class Inner{
            public void inner(){
                System.out.println("inner");
            }
            public void printId(){
                //能拿到外部类的私有属性
                System.out.println(id);
            }
        }
    }

    
    Outer outer=new Outer();
    Outer.Inner inner=outer.new Inner();
    inner.inner();
    inner.printId();

  • 静态内部类

    
    public class Outer {
        private static int id=10;
        public static class Inner{
        public void inner(){
           System.out.println("inner");
        }
        public void printId(){
                //能拿到外部类的静态私有属性  
                System.out.println(id);
        }
        }
    }

    
    Outer.Inner inner = new Outer.Inner();
    inner.inner();
    inner.printId();

  • 局部内部类(方法内)

  
  private int id=10;
  public Comparable<Integer> outer(){
      class Inner implements Comparable<Integer>{
         public void inner(){
             System.out.println("inner=>"+id);
         }
  ​
          @Override
          public int compareTo(Integer o) {
              return 0;
          }
      }
      return new Inner();
  }

  
  Comparable<Integer> comp= new Outer().outer();

  • 匿名内部类(没有名字) 常用于一次性的接口实现等

  •