【Java】类和对象

世界级白日梦冠军

已于 2022-11-10 17:31:59 修改

阅读量719

点赞数 9

分类专栏： JavaSE 文章标签： java jvm 开发语言

于 2022-10-24 22:09:02 首次发布

本文链接：https://blog.csdn.net/m0_50987960/article/details/127470331

版权

JavaSE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

3、 static修饰的静态域（静态属性，静态方法）和成员域（成员属性，成员方法）之间的关系

什么是面向对象 OOP：在java中一切皆对象，找对象，用对象。

三个重要思想：封装，多态，继承。

类的定义和使用

一、对象和类的关系

类内的方法叫成员方法，类内的变量叫成员变量。

一个源文件只能由一个主类 public class，但是class声明的普通类可以存在很多个。

类是一个模板，没有具体的意义，该类的所有对象都具备的成员属性和成员方法（行为）定义在类中。不同对象的属性值和具体表现的行为都是不同的。

通过产生的新类型产生具体对象就是类的实例化。当对象产生时，成员变量才有初始值。成员属性和成员方法必须通过具体的对象来调用。

public class Test {
    public static void main(String[] args) {
        dog dog = new dog();
        dog.name = "大黄";
        dog.bark();
        dog.wag();
    }
}
class dog {
    String name;
    public void bark(){
        System.out.println(name+"汪汪汪！");
    }

    public void wag(){
        System.out.println(name+"摇尾巴！");
    }
}

如上创建了普通类dog，一个成员变量name，两个成员方法bark和wag。

建立了新的对象dog，对name进行了初始化，调用了两个方法。

二、构造方法

初始化对象调用构造方法，构造方法就是为了产生对象，给对象属性做初始化操作。

构造方法和类名称相同，没有返回值类型声明，构造方法可以重载（重载的个数不同）。

当类中没有明确定义构造方法，编译器会生成默认的无参构造，若明确定义了构造方法，默认的无参构造就不再产生。

构造方法在创建对象时，由编译器自动调用，且指在对象产生时调用一次。

三、this关键字及其用法

1、修饰成员变量

直接在类中寻找同名的成员变量。

在自己创建的构造方法中使用this.name和this.age给名字和年龄赋值，如果不加this则会在该方法中寻找同名变量则无法赋值。

public class staticTest {
    public static void main(String[] args) {
        Japanese j1 = new Japanese("小泉",70);
        System.out.println(j1.toString());
    }
}
class Japanese{
    String name;
    int age;

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

    public static void test(){
        System.out.println("静态方法test");
    }
    public static void fun(){
        System.out.println("静态方法fun");
    }

    public String toString() {
        return "Japanese{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                '}';
    }
}

2、修饰方法

2.1修饰成员方法

在一个成员方法中调用另一个成员方法。

public class number {
    public static void main(String[] args) {
        Person person = new Person("洋洋",22);
        person.test();
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void test(){
        this.fun();
    }
    public void fun(){
        System.out.println("姓名为"+this.name+"，年龄为"+this.age);
    }
}

如上述代码，在test方法中调用了fun函数。

2.2调用构造方法

必须写在构造方法中的首行，并且不能成环。

ublic class number {
    public static void main(String[] args) {
        dog dog = new dog("大黄","黄色");
    }
}

class dog {
    String name;
    String color;

    public dog(){
        System.out.println("自己定义的无参构造！");
    }

    public dog(String name, String color) {
        this(name);
        System.out.println("自己定义的name和color的赋值构造");
        this.color = color;
    }

    public dog(String name) {
        this();
        System.out.println("自己定义的namer的赋值构造");
        this.name = name;
    }
}

如图创建对象时调用的是自己定义的赋值给name和color的构造函数，在该构造函数中调用了给name赋值的构造函数，有调用了无参构造函数。

3、表示当前对象引用

public class number {
    public static void main(String[] args) {
        Person person = new Person("洋洋",22);
        System.out.println(person);
        person.test1();
    }
}
class Person{
    String name;
    int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void test1(){
        System.out.println(this);
    }
}

test1方法中就调用了当前对象，所以输出的结果和直接数值对象是一样的。

四、static关键字以及用法

表示静态，与类相关，和具体的对象无关。

1、static修饰属性

称之为类属性，存放于JVM的方法区。该类的所有对象共享此属性。

public class staticTest {
    public static void main(String[] args) {
        Japanese j1 = new Japanese("小泉",70);
        System.out.println(j1.toString());
    }
}
class Japanese{
    String name;
    int age;
    static String country = "日本";

    public Japanese(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return "Japanese{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                '}';
    }
}

在Japanese类中用static修饰了country变量，所以在定义时就对其进行赋值，不需要在生成对象时再次赋值就可以直接显示它的country。

2、static修饰方法

类方法，直接通过类名称调用，与对象无关。

一个类的工具方法一般设计为静态方法，与具体的对象无关。

public class staticTest {
    public static void main(String[] args) {
        Japanese.fun();
        Japanese.test();
    }
}
class Test{

    public static void test(){
        System.out.println("静态方法test");
    }
    public static void fun(){
        System.out.println("静态方法fun");
    }

}

直接用类的名称调用用static修饰的成员方法，不能用对象调用。

3、 static修饰的静态域（静态属性，静态方法）和成员域（成员属性，成员方法）之间的关系

不能在静态方法中访问成员域。

在成员方法中可以访问静态域但是不推荐，一般还是使用类名称。

4、static变量的初始化

静态变量一般就地初始化或在静态代码块初始化。

五、代码块

1、普通代码块

直接定义在方法内部，不加任何修饰符定义的代码块称为普通代码块。

用于解决变量重名问题。

2、构造块

直接定义在类中，使用{}的代码块称之为代码块。

特点：每当产生对象时就会默认调用构造块，构造块优先于构造方法执行。

public class CodeSquare {
    public CodeSquare(){
        System.out.println("1、无参构造");
    }
    {
        System.out.println("2、构造块");
    }

    public static void main(String[] args) {
        CodeSquare c1 = new CodeSquare();
        CodeSquare c2 = new CodeSquare();
    }
}

创建了两个类，则构造方法和构造块都调用了两次，每次构造块都在构造方法前面。

3、静态代码块

使用static修饰，直接定义在类中的代码块称为静态代码块。

static修饰主方法所以在主方法中也不能使用this调用别的类的方法或者属性。

特点：静态代码块在类加载时执行一次，和具体产生对象无关。若有多个静态代码块，按照代码的书写顺序依次执行。

静态代码块优先于所有别的代码块。

public class CodeSquare {
    public static void main(String[] args) {
        Demoo d1 = new Demoo();
    }
}
class Demoo{
    static int i;
    public Demoo(){
        System.out.println("1、无参构造");
    }
    {
        System.out.println("2、构造块");
    }
}

静态代码块在构造块前面，构造块在构造方法前面。

主类中的静态代码块优先于主方法执行。

public class CodeSquare {

    static {
       System.out.println("3、主方法的静态块");
   }

    public static void main(String[] args) {
        System.out.println("4、主方法");
        CodeSquare c1 = new CodeSquare();
    }
}

主方法静态代码块在主方法前面。