面向对象基础

面向对象基础

3.1面向对象的概念

程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的关系，这种思想就是面向对象。

面向对象三大特性

• 封装：将对象的属性和行为封装起来，不需要让外界知道具体实现细节
• 继承：描述类和类之间的关系。通过继承，可以无需重写原有类的情况下，对原有类的功能进行拓展
• 多态：多态性指在程序中允许出现重名的现象，它指在一个类中定义的属性和方法被其他类继承后，它们具有不同的数据类型或表现出不同的行为，使得一个属性有不同的语义。

3.2类和对象

类的定义

public class Person {
    //定义类的属性
    int age;
    //定义类的方法
    void speak(){
        System.out.println("Speaking");
    }
}

类的创建和使用

public class Demo {
    public static void main(String[] args) {
        Person person1=new Person();
        Person person2=new Person();
        person1.age=10;
        person2.age=100;
        person1.speak();
        person2.speak();
    }
}

类的封装

public class Person {
    //定义类的属性为私有，外部变量不可以直接访问
    private int age;
    //留一个接口，给外部变量获得age的值
    public int getAge() {
        return age;
    }
    //检查输入的age是否合法，如果合法才赋值
    public void setAge(int age) {
        if(age>0&&age<120) {
            this.age = age;
        }else {
            System.out.println("你输入的年龄不合法");
        }
    }
    //定义类的方法，用来描述对象的行为
    void speak(){
        System.out.println("I am "+age+ "years old");
    }
}

public class Demo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.setAge(120);
        person1.speak();
    }
}

3.3构造方法

构造方法的定义

• 条件

  ①方法名和类名相同

  ②在方法名的面前没有返回值类型的声明

  ③在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束

  public class Person {
      int age;
      String name;
      //无参构造
      Person(){
          System.out.println("调用无参构造器");
      }
      //有参构造
      Person(int age,String name)
      {
          this.age=age;
          this.name=name;
          System.out.println("调用有参构造器");
          System.out.println("age:"+age+"\nname"+name);
      }
  }
  
  

  public class demo {
      public static void main(String[] args) {
          //在实例化对象时会自动调用该类的构造方法
          Person person=new Person();
          Person person1=new Person(6,"Tom");
      }
  }
  

3.4this关键字

• 通过this明确访问一个类成员变量

  public class Person {
      int age;
      String name;
      Person(int age,String name)
      {
          this.age=age;
          this.name=name;
      }
  }
  

• 通过this关键字调用成员方法

  public class Person {
      void openMouth()
      {
          System.out.println("speak");
      }
      void speakWord()
      {
          this.openMouth();
          System.out.println("word");
      }
  }
  

• 构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但是可以在一个构造方法中使用this关键字来调用其他构造方法

  public class Person {
      int age;
      String name;
      //无参构造
      Person(){
          System.out.println("调用无参构造器");
      }
      //有参构造
      Person(int age,String name)
      {
          this();//调用无参构造方法
          System.out.println("调用有参构造方法");
      }
  }
  

  • 注意：

    ①只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。

    ②在构造方法中，使用this调用构造方法的语句必须放在第一行，且只能出现一次

    ③不饿能在一个类的两个构造方法中this相互调用

3.5static关键字

静态变量

用static关键字修饰的成员变量称为静态变量，静态变量被所有实例共享

public class Student2 {
    static String school;
}

public class Demo {
    public static void main(String[] args) {
        Student2.school="THU";
        Student2 stu1=new Student2();
        Student2 stu2=new Student2();
        System.out.println(stu1.school);
        System.out.println(stu2.school);
    }
}

static只能修饰成员变量，不能用于修饰局部变量

静态方法

static修饰的方法称为静态方法，静态方法既可以通过对象来访问，也可以通过类来访问

public class Person {
    public static void Say()
    {
        System.out.println("hello");
    }
}

public class Demo {
    public static void main(String[] args) {
        //通过类访问
        Person.Say();
        //通过对象访问
        Person p=new Person();
        p.Say();
    }
}

静态代码块

• 在Java中，使用一个大括号包起来的若干行代码称为一个代码块。
• 用static关键字修饰的代码块称为静态代码块
• 类加载时，静态代码块会被执行，由于类只加载一次，所以静态代码块也只执行一次
• 静态代码块常用于对成员变量进行初始化

public class Student {

    {
        //代码块（匿名代码块）
        //创建对象时创建
        //可以通过匿名代码块来赋初始值
        System.out.println("匿名代码块");
    }
    static{
        //静态代码块（匿名代码块）
        //类一加载就执行，只执行一次
        System.out.println("静态代码块");
    }
    public Student(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Student s1=new Student();
        Student s2=new Student();
    }
}

3.6成员内部类

• 在类里面定义的类称为成员内部类

  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);
          }
      }
  }