Java面向对象基础

面向对象基础

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

posted on 2021-01-09 20:32 Miranda2021 阅读(101) 评论(0) 收藏举报