亲宝软件园·资讯

展开

Java 类与对象 Java 类与对象重难点详解

Lockey-s 人气:0
想了解Java 类与对象重难点详解的相关内容吗,Lockey-s在本文为您仔细讲解Java 类与对象的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java,对象,Java,类,下面大家一起来学习吧。

什么是类、对象?

因为计算机并不能像我们人这样去理解世界上的东西,所以为了更好的编辑,就抽象出了类和对象。类就是把功能放在一起,然后由一个人去调用这个功能,然后再编辑对应的功能。调用者就是对象的实现者

类和类的实例化

类是一类对象的统称,对象就是这一类具体化的实例
创建类的关键字:class

举例:我们坐年糕的模子就是一个类,而通过这个模子可以做出月饼。在这个例子当中,类就是模具,年糕就是实例化的对象。一个类可以实例化很多对象。举例:

class Person {
    public String name;
    public int age;
}
public static void main1(String[] args) {
    Person person1 = new Person();
    Person person2 = new Person();
    Person person3 = null;
}

Person 就是一个类,里面的 name 和 int 就是类的成员(字段)。这里的 person1 就是引用,指向的是后面 new 的对象,因为是引用,所以也可以指向 null 。person3 就是指向空(null)引用。person1 person2 person3 就是实例化的对象。

字段的初始化

字段就是类里面的成员。在创建这些成员的时候就可以初始化。例如:

class Person {
    public String name = "Lockey";
    public int age = 10;
}

这里就是创建的时候对其进行初始化。其实并不建议直接初始化,建议在类的调用者使用的时候再初始化。如下:

class Person {
    public String name;
    public int age;
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.name = "Lockey";
    person1.age = 10;
    System.out.println(person1.name);
    System.out.println(person1.age);
}

这里就是在类的调用者里面对类的字段进行赋值,在 main 方法当中通过引用调用。

在这里插入图片描述

类当中实现方法

就像上面的例子,如果类的调用者需要名字和年龄的时候,输出两行比较麻烦,类的实现者就可以在类内写一个方法,直接返回名字和年龄。示例:

class Person {
    public String name;
    public int age;
    public void print() {
        System.out.println("姓名:"+name+" 年龄:"+age);
    }
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.name = "Lockey";
    person1.age = 10;
    person1.print();
}

在这里插入图片描述

static 静态关键字

static 可以修饰方法,属性。要注意的是:static 修饰的变量通过类名访问。直接举例说明:

class Person {
    public int a;
    public static int count;
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.a++;
    person1.count++;
    System.out.println(person1.a);
    System.out.println(Person.count);
    Person person2 = new Person();
    person2.a++;
    person2.count++;
    System.out.println(person2.a);
    System.out.println(person2.count);
}

在这里插入图片描述

如图,count 第二次输出为 2 。这是因为 conut 是被 static 修饰的变量,被 static 修饰之后就变成了常量,就在静态区了。所以每个引用当中调用的 count 没变。所以第二次改变 count 的值的时候,就变成 2 了。当 static 修饰方法的时候,无需再创建对象,直接拿类名调用就行了。举例:

class Person {
    public static int count;
    public static void change() {
        count = 100;
    }
}
public static void main(String[] args) {
    Person.change();
    System.out.println(Person.count);
}

在这里插入图片描述

通过类名的调用直接访问 static 修饰的变量。

封装

因为代码实现的软件很复杂,所以就出现了类,但是为了阅读性更高,就出现了封装。就是把一个类的内容实现为只剩一个或几个接口,方便类的调用者访问,这样就降低了代码的复杂程度。

private 实现封装

private 就是修饰成员变量或方法的关键字,被 private 修饰之后,就不能被类外的调用者访问了。所以就可以配合 public 来实现对外的接口。例如:

class Person {
    private String name = "Lockey";
    private int age = 10;
    public void print() {
        System.out.println("名字是:"+name+" 年龄:"+age);
    }
}
public static void main(String[] args) {
    Person person = new Person();
    person.print();
}

在这里插入图片描述

这里就是利用 private 封装属性,使其只能在类内被访问到。而提供的 public 接口,就让类的调用者在类外就可以访问到了。所以在类外直接调用 print 方法就好了。

setter 和 getter 方法

当我们把字段(name age)设置为 private 属性时,就无法在类外进行初始化了,所以就又出现了新的方法:

setter :在类外直接调用此方法,然后设置一个值。

有了 setter 就又有了 getter 方法。getter 就是获取字段数的值。通过类外调用,将字段设置为此值。代码示例:

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name1) {
        name = name1;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age1) {
        age = age1;
    }
    public void print() {
        System.out.println("名字是:"+name+" 年龄:"+age);
    }
}
public static void main(String[] args) {
    Person person = new Person();
    person.setName("Lockey");
    person.getName();
    person.setAge(10);
    person.getAge();
    person.print();
}

在这里插入图片描述

这里就是调用 getter 和 setter 方法,在类外进行访问,因为 private 对 name 和 age 做了封装。

构造方法

方法名和类名是相同的,且构造方法没有返回值。调用完构造方法之后,对象才会产生。

一个对象的产生:
1 为对象分配内存。
2 调用合适的构造方法。

class Person {
    public Person() {
        System.out.println("Person 不带参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person();
}

在这里插入图片描述

这里就是实例化类的对象的时候调用的构造方法,因为我们自己写了构造方法,所以这里就调用我i们写过的。就输出了如图所示的内容。需要注意的是:如果没有实现如何的构造方法,编译器会帮我们默认生成有个不带参数的构造方法。也就是说,一个类,至少会有一个构造方法。

除了上面这种构造方法,我们还能写带有参数的构造方法。例如:

class Person {
    private String name;
    public Person(String name1) {
        name = name1;
        System.out.println("Person(String) 带一个参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey");
}

在这里插入图片描述

如图:在类初始化的时候,传入参数 “Lockey” 在类实例化的时候就是调用有参数的构造方法。既然能传参数,那是否可以传多个参数呢?答案是可以的。例如:

class Person {
    private String name;
    private int age;
    public Person(String name1, int age1) {
        name = name1;
        age = age1;
        System.out.println("Person(String, int) 带两个参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey",10);
}

在这里插入图片描述

如图,调用的就是传了两个参数的构造方法。通过观察上面的例子,我们可以发现:构造方法也是支持重载的。

this 关键字

在类当中,this 表示当前对象的引用(不是当前对象),可以通过 this 来访问类当中的字段和方法。用 this 的话,会降低出现 bug 的概率,并且增加代码的可读性。例如使用 getter 和 setter 的时候,就可以用 this ,能多用 this 就多用 this 。

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

匿名对象

匿名对象就是没有名字的对象。

没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

代码示例:

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void print() {
        System.out.println("名字是:"+name+" 年龄:"+age);
    }
}
public static void main(String[] args) {
    new Person("Lockey",10).print();
}

在这里插入图片描述

匿名对象的缺点就是只能调用一次。

加载全部内容

相关教程
猜你喜欢
用户评论