Java面向对象基本用法

面向对象

面向对象编程

• 本质：以类的方式组织代码，以对象的方式最值（封装）数据

• 三大特性：

  • 封装
  • 继承
  • 多态

创建与初始化对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法。是在进行创建对象的时候必须调用的。并且构造器有一下两个特点
  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

public class Student{
    string str_name;
    int i_age;
}

注意

若类中同时存在有参和无参构造方法，如果无参方法中进行操作就会报错

封装

• 该露的露，该藏的藏

  • “高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用

• 封装

  • 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏

• 属性私有，get/set

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界个更好的建模
• extends的意思是”扩展“。字类是父类的扩展
• JAVA中类只有单继承，没有多继承
• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
• 继承关系的两个类，一个为子类，一个为父类。子类继承父类，使用关键字extends来表示
• 字类和父类之间，从意义上讲应该具有”is a“的关系
• object类
• super
• 方法重写

//在Java中，所有的类都默认直接或者间接继承Object类
public class Person /*extends Object*/

public class Person{
    protected String name = "Airex";
    public void print(){
        System.out.println("Person");
}
}

public class Student extends Person{
    private String name = "yuxi";
    public void test(String name){
        System.out.println(name);  //传递的name
        System.out.println(this.name);  //类中的name
        System.out.println(super.name);  //父类的name
}
    public void print(){
        System.out.println("Student");
}
    public void test(){
        print();//类中的print函数
        this.print();//类中的print函数
        super.print();//父类的print函数
    }
}

public class Student extends Person{
    super();  //当实例化Student对象的时候，super函数会隐式调用，即Person类会实例化一次，从而Student可以继承Person，而且super函数调用必须在代码段的第一行
}

//如果类中定义了有参构造方法，那么如果对象要调用无参构造方法，则无参构造方法必须显示声明，如果父类中只有有参构造方法，没有声明无参构造方法，那么子类中就不可以调用super()方法，同样子类也不可以调用无参构造方法，因为子类继承于父类

super注意点

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

this和super的区别

1. 代表的对象不同，this代表自身，super代表父类
2. this没有继承也可以用，super只有在继承条件下才可以使用
3. this() 是本类的构造，super()是父类的构造

方法重写： 重点—>多态

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大但不能缩小，意思是子类继承的方法修饰符范围可以扩大
4. 抛出的异常范围可以缩小不能扩大，子类异常范围一定小于父类的异常范围

多态

• 一个对象的实际类型是确定的，可以指向的引用类型有很多
• 多态是方法的多态，属性无多态
• 存在条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

//，父类的引用可以指向子类，从而实例化父类，但无法调用子类的独有的方法，如果父类中的某个方法被子类重写，那么当父类调用该方法就会执行子类重写的代码，但是可以通过强制转换来调用父类中不存在的子类独有的方法，强制转换只有在有父子关系的两个类才能进行（ClassCastException,类型转换异常）

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

((Student) s2).eat(); //通过强制转换将父类转化为子类类型，所以可以调用子类中独有的方法

无法重写的方法类型

1. static
2. final
3. private

instanceof

• 测试两个类有无继承关系，从而判断是否能可以进行类型强制转换

Object object = new Student();
Person object2 = new Student();
System.out.println(object instanceof Student);  //instanceof为true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false

System.out.println(object2 instanceof String);//会直接报错，因为Person与String没有父子关系

类型转换

Student student = new Student();
Person person = new Student();//低向高自动转换
(Student)Person = new Student();//高向低强制转换
//子类转化为父类，可能会丢失自己的本来的一些方法！！！加入子类中有eat()这个方法，而父类中没有，则一下代码错误
person.eat();

static

• static方法，属性跟类一起加载
• 静态方法无法调用非静态方法，非静态方法可以调用静态方法
• 类可以直接调用静态方法， 不能直接调用非静态方法，但可以通过实例化对象来调用

package exercise;
import java.util.Scanner;

public class Student  {
    private static int age;
    private double score;
    public void run(){
        go();  //非静态方法可以调用静态方法
    }
    public  static void go(){
        run(); //静态方法无法调用非静态方法
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.run();
        System.out.println(Student.score); //非静态属性无法通过类直接调用
        System.out.println(Student.age);  //静态属性可以直接被类调用
    }

}

代码块

• 匿名代码块，每次实例化对象都执行一次，一般用来赋初值
• 静态代码块，只执行一次，跟类一起加载
• 构造方法，每次实例化对象都执行一次

public class Person{
    {
        System.out.println("匿名代码块"); //赋初值
    }
    static{
        System.out.println("静态代码块"); //只执行一次
    }
    public Person(){
        System.out.println("构造方法");
    }
}
// 执行顺序 静态代码块-->匿名代码块-->构造方法

静态导入包

import static java.lang.Math.random;
public class Student extends Person {
    System.out.println(random()); //可以直接使用random方法
    //System.out.println(Math.random()); 不使用静态导入包
}

抽象类

• 抽象类可以定义普通方法，普通类中不能定义抽象方法
• 抽象方法中无方法体
• 抽象类不可以实例化，只能由子类实现
• 子类如果是普通类，父类是抽象类，必须实现父类的抽象方法；子类如果是抽象类，则可以不实现父类的抽象方法

public abstract class Action{
    public class Fun{};
    public abstract class doSomething{}; 
}

接口

• 普通类：只有具体实现

• 抽象类：具体实现和规范（抽象方法）都有

• 接口：只有规范，约束和实现分离，面向接口编程

• 接口的本质是契约

• 接口不能被实例化，接口无构造方法

  public interface UserService {
      int name; //接口中的属性都是常量，即用public static final修饰
      void fun();
      public abstract void getNum();  //接口中的方法都是隐式public和abstract的
  }
  

  public class User implements UserService{ //接入接口的类必须实现接口中的所有方法,也可以有多个接口
      public void fun(){
          
      }
      public void getNum(){
          
      }
  }
  

内部类

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

• 成员内部类

  

  

  public class Outer{   //一个文件中只能有一个public class类，但可以有很多个普通类
      
  }
  class Temp{
  }
  

• 静态内部类

• 局部内部类

  public class Outer{
      public void fun(){
          class Inner{
              System.out.println("内部类");
          }
      }
  }
  

• 匿名内部类

public class test{
    public static void main(String[] args){
        new Apple().eat();  //没有定义变量，称为匿名内部类
        new UserService(){  //匿名的接口，里面需要重写接口的方法，会返回一个接口对象
            
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("!");
    }
}

interface UserService{
    
}