Java基础笔记（五）面向对象

• 面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据

• 三大特性：

  • 封装
  • 继承
  • 多态

5.1.2 break和return的区别

• break：跳出循环
• return：跳出方法，返回一个返回值

5.1.3 值传递和引用传递

• 值传递

  public static void main(String[] args){
      int a = 1;
      System.out.println(a);//1
      Demon.change(a);
      System.out.println(a);//1
  }
  public static void change(int a){
      a = 10;
  }
  

• 引用传递

  public static void main(String[] args){
      Person person = new Person();
      
      System.out.println(person.name);
      Demon.change(person);
      System.out.println(person.name);
  }
  public static void change(Person person){
      person.name = "toolate";
  }
  

5.1.4 this

• 在一个类中需要调用自己的属性时，用***this.属性***来调用
• this只能放在第一行

5.1.5 构造器

• 构造器写在类里面，构造器方法名和类名相同，实例化对象时（new对象）会运行构造器，构造器中可以初始化属性。构造器没有返回值

• 构造器有两种：

  • 有参构造
  • 无参构造

5.2.1 封装

• “高内聚，低耦合”
• 属性私有，get/set

5.2.2 继承

• 类A+extends+类B即类A继承类B

• public的属性在继承时会被全部继承

• private的属性无法继承

• public>protected>default>private

• Java中只有单继承，没有多继承

5.2.3 Super

• 调用父类的方法
• this.name表示当前类的name
• super.name表示父类的name
• super无法调用父类中private的属性和方法
• super()表示调用父类的构造器，且必须放在第一行
• super必须只能出现在子类的方法或者构造方法

5.2.4 方法重写

• 重写是方法的重写，和属性无关

• 父类的引用指向子类

• 静态方法：方法的调用只和左边定义的数据类型有关

• 非静态方法：重写

• 参数列表必须相同；

• 返回类型必须一直与被重写的方法相同，否则不能称其为重写；

• 访问修饰符的限制一定要大于等于被重写方法的访问修饰符；

• public>protected>default>private

• 一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

5.2.5 多态

• 父类的引用指向子类

  Student s1 = new Student();
  Person s2 = new Student();
  Object s3 = new Student();
  

  对象能执行哪些方法，主要看对象左边的类型，和右边关系不大。

• 注意：

  • 多态是方法的多态，属性没有多态
  • 父类和子类必须有联系，否则会类型转换异常（ClassCastException）
  • 方法需要重写
  • 父类引用指向子类对象

• 以下方法不能重写：

  1. static 方法，属于类，不属于实例
  2. final 常量
  3. private 方法

5.2.6 Instanceof

• 类型转换 引用类型，判断一个对象是什么类型
• A instanceof B不能编译表示A和B没有关系
• A instanceof B为真表示A是B的父类

5.2.7 Static

private static int age;//静态
private double score;//非静态

Student s1 = new Student();

System.out.println(Student.age);//类变量
System.out.println(Student.score);//错误，student的score非静态
System.out.println(s1.age);
System.out.println(s1.score);

Static方法和类一起加载

静态代码块只执行一次，实例化两个对象也只执行一次

• 静态导入包

  import static java.lang.Math.random;
  System.out.println(random());
  

  • 用static静态导入包中的方法后，调用方法时不再需要用包+.+方法了，而是直接使用方法

• Static属性和方法

  使用了Static的属性属于类，不属于对象，

  使用了Static的方法书序类，不属于对象，不需要创建对象，直接使用类名称来使用

  • 静态方法不能直接访问非静态方法
  • 静态方法不能使用this

5.2.8 抽象类

• abstract：

  • 用在方法上：只有方法名字，没有方法的实现

    public abstract void doSomething();
    

  • 继承了抽象类的子类必须要实现它的方法，除非子类也是抽象类

1. 抽象类不能实例化。
2. 抽象类里面可以写普通方法，抽象方法必须在抽象类中

• 抽象类的作用：将需要反复继承中的一些相同的属性抽象出来，减少代码冗余

5.2.9 接口

• 接口的本质是契约，用于约束

• 接口中所有定义的方法都是public abstract，所以不需要写

• 接口中所有定义的值都是public static final的常量

• 接口并没有实现，需要implement来实现

• 实现了接口的类必须要重写接口中所有的方法

• 接口可以多继承

• public class UserServiceImpl implements UserService,TimeService{
  }
  

5.2.10 内部类

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

• public class Application{
      public static void main(String[] args){
  		Outer outer = new Outer();
          //通过外部类来实现内部类
          Outer.Inner inner = outer.new Inner();
          inner.getID();
      }
  }
  

• 内部类能访问外部类的私有方法和属性

• 一个java类中可以有多个class，但是只能有一个public class

5.3.1 final

• final关键字代表最终、不可改变的
• 修饰类：不能有子类，所以其中所有的成员方法都无法覆盖重写
• 修饰方法：最终方法，不能被覆盖重写
• 修饰局部变量：一旦使用final修饰局部变量，就不能再更改
• 修饰成员变量：使用final关键字修饰，那这个变量也不可变