Java基础总结(三)类与对象(上)-优快云博客

本文详细介绍了Java语言的基础语法，包括类的定义、对象创建、this关键字的使用、构造方法、方法重载、面向对象的三大特性（封装、继承、多态）、初始化块等内容。

Java语言里定义类的语法：

[修饰符] class 类名{
    零到多个构造器定义..
    零到多个成员变量..
    零到多个方法..
}

创建对象
在Java中，提供了名为构造器的一种特殊方法，若某一个类有一个构造器，那么创建对象时，Java会自动调用那个构造器。

Person p; //使用Person类定义一个Person类型的变量
p = new Person(); //通过new关键字调用Person类的构造器，返回一个Person实例，再将该实例赋给变量p

这里写图片描述

this关键字

Java提供了一个this关键字，this关键字总是指向调用该方法的对象。

构造器中引用该构造器正在初始化的对象
在方法中引用调用该方法的对象

public class Test {
    private String name;
    private int age;

    public Test(String name,int age) {
        this.name = name;//this调用属性
        this.age = age;
        System.out.println("名字是"+name+"年龄"+age);
    }

    public Test() {
        this("武装",18);
        System.out.println("无参构造器");
    }
    public void test() {
        System.out.println("普通方法");
    }
    public void run() {
        this.test();//this调用方法
    }
    public static void main(String[] args) {
        Test t = new Test();
    }
}

引用传递（分析内存）

public class Test {
    public static void main(String[] args) {
        String str = "hello";
        fun(str);
        System.out.println(str);
    }
    public static void fun(String temp) {
        temp = "world";
    }
}
//输出是 hello

public class Test {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public static void main(String[] args) {
        Test t = new Test();
        t.setName("hello");
        fun(t);
        System.out.println(t.getName());
    }
    public static void fun(Test temp) {
        temp.setName("world");
    }
}
//输出是world

方法重载 overload

Java允许同一个类定义多个同名方法，只要形参列表不通就行。构造方法也可以重载

public class Test {
    public void run() {
        System.out.println("无参方法");
    }
    public void run(int n) {
        System.out.println("有参方法"+n);
    }
    public static void main(String[] args) {
        Test t = new Test();
        t.run();
        t.run(3);
    }
}

面向对象三大特性

封装

将对象的成员变量和实现细节隐藏起来，不允许外部直接访问。把方法暴露出来，让方法控制对这些成员变量进行安全的访问和操作。

访问控制符
private –> default –> protected –> public

这里写图片描述

继承

Java的继承用extends关键字来实现，实现继承的类被称为子类。被继承的类称为父类。一般用于在已有的基础上进行功能扩充。

修饰符 class SubClass extends SuperClass{
    //类定义部分
}

父类的无参构造方法之所以被执行，是因为java规定，子类在构造之前必须先构造父类。

事实上，子类的构造方法中是必须要通过super关键字来调用父类的构造方法的，这样才可以保证妥善的初始化继承自父类的成员变量。

但是看上一个案例中的代码并没有super调用父类构造方法，那是因为，如果子类的构造方法中没有调用父类的构造方法，则java编译器会自动的加入对父类无参构造方法的调用。

public class Animal {
    protected String name;
    protected int age;

    public Animal() {
        System.out.println("父类构造方法");
    }

    public void run() {
        System.out.println("运动");
    }
}
class Cat extends Animal{
    public Cat() {
        //默认调用父类无参构造方法super();
        System.out.println("子类构造方法");
    }
    public static void main(String[] args) {
        Cat c = new Cat();
        c.name = "猫咪";
        c.run();
    }
}

多态

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

public class Animal {
    private String name;
    public void run() {
        System.out.println("跑路");
    }
    public void fly() {

    }
    public static void main(String[] args) {
        Animal c = new Dog();
        Animal a = new Cat();
        c.fly();
        a.fly();
    }
}
class Cat extends Animal{
    public void fly() {
        System.out.println("飞翔");
    }
}
/**
    方法重写 override
**/
class Dog extends Animal{
    public void fly() {
        System.out.println("叫");
    }
}

因为子类是一个特殊的父类，因此Java允许把一个子类对象直接赋给一个父类引用变量，被称为向上转型。当把一个子类对象直接赋给父类引用变量时，例如上面的Animal c = new Cat();这个c引用变量的编译类型是Animal，而运行时是Cat类型，这就可能出现：相同类型的引用变量，调用同一个方法时呈现出多种不同的行为特征，这就是多态。

instanceof运算符
instanceof运算符的前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类，它用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是则返回true,否则返回false。

public class Animal {
    public static void main(String[] args) {
        Animal a = new Animal();
        System.out.println(a instanceof Animal);
    }
}
//true

初始化块

初始化块是Java类里可出现的第4种成员（前面依次是成员变量、方法、构造器）一个类里可以有多个初始化块，相同类型的初始化块之间有顺序：前面定义的初始化块先执行，后面定义的则后执行。

修饰符 {
    ...
}

初始化块里的代码开一个包含任何可执行语句，包括定义局部白能量、调用其他对象的房，以及使用分支、循环等。

普通初始化块（负责对对象执行初始化）

public class TestStatic {
    {
        System.out.println("初始化块");
    }
    public TestStatic() {
        System.out.println("构造方法");
    }
    private String name;

    public void run() {
        System.out.println("奔跑");
    }
    public static void main(String[] args) {
        System.out.println("main方法");
        TestStatic ts = new TestStatic();
        ts.run();
    }
}
//输出结果：
main方法
初始化块
构造方法
奔跑