Java学习---JavaSE----面向对象

面向对象

**面向对象编程的本质就是:**以类的方式组织代码，以对象的组织(封装)数据。

三大特征：封装，继承，多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

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

方法的调用

引用传递

//引用传递：对象，本质还是值传递
public class Dome1 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name);
        change(perosn);
        System.out.println(perosn.name);
    }
    public static  void change(Perosn perosn){
        perosn.name="dj";
    }
}
class Perosn{
    String name;
}

创建与初始化对象

使用new关键字：使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

构造方法：类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

1.必须和类的名字相同;

2.必须没有返回类型,也不能写void;

public class Perosn {
    //一个类型即使什么都不写，它也会存在一个构造方法（默认）
    String name;
    //实例化初始值
    //使用new关键字，本质是在调用构造器
        //快捷键：alt+insert
    public Perosn() {
    this.name = "xdkj";
    }
    //有参构造：一旦定义有参构造，无参构造必须定义
    public Perosn(String name){
        this.name=name;
    }
}

封装、继承和多态

*分装

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外干涉;**低耦合:**仅暴露少量的方法给外部使用。

快速生成属性个get和set:alt+insert+Getter and Setter

*继承

本质：对某一批类的抽象。所有的类都继承object，私有的无法被继承

extands的意思是“扩展”。子类是父类的扩展

A类 extands B类   A继承了B

只有单继承

• 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
• 子类和父类之间,从意义上讲应该具有"is a”的关系.

**查看继承关系：**ctrl+H 在idea

*super

子类调用父类属性和方法：super.父类的属性和方法

注意：

• 调用父类的构造方法，必须在调用子类构造方法前

• 默认先调用父类的无参构造方法再调用子类的无参构造方法。

• super和this不能同时调用构造方法

• this调用本身这个对象

• super代表父类对象的应用，只能在继承后使用

*重写

注意：是方法的重写和属性无关

public class DomePer1 {
    public  static void  test(){
        System.out.println("A=>text");
    }
}

public class DomeStu1 extends DomePer1 {
    public  static void  test(){
        System.out.println("B=>text");
    }
}

public class Dome1 {
    //静态方法和非静态方法有很大的区别
    public static void main(String[] args) {
        //静态方法：方法的调用只和左边，定义的数据类型有关
        DomeStu1 b=new DomeStu1();
        b.test();
        //父类的引用指向子类
        DomePer1 a=new DomeStu1();
        a.test();
    }
}

*多态

• 动态编译:类型
• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性。

注意：

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系，类型转换会异常（ClassCasException）
• 存在条件：继承关系，方法需要重写，父类引用指向子类
• 不能重写：
  • static 方法，属于类，不属于实例
  • final 常量
  • private 方法

static

static{
    //只执行一次
     System.out.println("A=>text");
}

抽象类

• abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
• 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
• 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的
• 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
• 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

//类只能单继承，接口可以多继承
public abstract class A {
    //abstract ,抽象方法,只有方法名字，没有方法的实现!
    public abstract void Test();
}
//加象类的所有方法，继承了它的子类，都必须要实现它的方法~除非也是abstract
public class B extends A {
    @Override
    public void Test() {
        System.out.println("cxs");
    }
}

接口

声明接口的关键字是interface，接口的本质是契约

接口:只有规范!自己无法写方法_{专业的约束!约束和实现分离:面向接口编程}

//接口都要有实现类
public interface UserService {
    //常量~public static final
    int Age=88;
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void select(String name);
}

public interface TimeService {
    void timer();
}

//类可以实现接口implements
//实现接口的类，必须重写接口中的方法
//多继承
public class UserServiceImp implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void select(String name) {

    }

    @Override
    public void timer() {

    }
}

注意：接口不能实例化_{，接口中没有构造方法}

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

• 成员内部类

  public class Outer {
      private int id;
      public  void  out(){
          System.out.println("这是外部类的方法");
      }
      public class Inner{
          public void in(){
              System.out.println("这是内部类的方法");
          }
          //访问外部类字段
          public void getID()
          {
              System.out.println(id);
          }
      }
  }
  
      public static void main(String[] args) {
          Outer outer=new Outer();
          //通过这个外部类来实例化内部类
          Outer.Inner inner=outer.new Inner();
          inner.getID();
      }
  

• 静态内部类

  public class Outer {
      private int id;
      public  void  out(){
          System.out.println("这是外部类的方法");
      }
      public static class Inner{
          public void in(){
              System.out.println("这是内部类的方法");
          }
      }
  }
  

• 局部内部类

  public class Outer {
      //局部内部类
      public  void  out(){
          class Inner{
              
          }
      }
  }
  

• 匿名内部类

  public class Appliction {
      public static void main(String[] args) {
          //没有名字初始化类
          new Inners().eat();
      }
  }
  class Inners{
      public void eat(){
          System.out.println("1q");
      }
  }