java中类与对象回顾总结-2

简介: java中类与对象回顾总结

java中类与对象回顾总结-1

https://developer.aliyun.com/article/1503952


三 类的方法

方法:用来描述对象的行为

对于一种特殊的称为构造方法,在后面的文章中详细讲解,本篇文章主要讲解类的普通方法。

(1)普通成员方法

class Person{
    public static int count;
    public String name;
    public int age;
    public void eat(){
        System.out.println(name+"在睡觉");
    }
    public void sleep(){
        change();
        //Static int one = 1;error
        System.out.println(name+"在吃饭");
    }
    public static void change(){
        //sleep()error
        count=10;

    }

}
public class practiceone{
    public static void main(String[] args) {
        Person person = new Person();
        person.name="java";
        person.eat();
        person.sleep(); 
        }
}    

在普通成员方法是可以对静态方法进行调用,但是在静态方法里面是不能定义静态成员变量的,这是因为静态成员变量是属于类的,而不属于方法。


(2)静态成员方法

从上面代码分析可以得出,静态成员方法内不能调用普通成员方法,因为静态方法与静态成员变量都是属于类的,不依赖于对象。而普通成员方法依赖于对象。也说明静态方法不能直接使用普通成员变(非静态数据成员)。


类与对象的关键E点:

静态变量与静态方法属于类,而且两者都不依赖于对象

对于普通成员方法以及普通成员变量都必须依赖于对象,换句话说必须要通过关键字new去进行实例化对象。


疑难解答:

问:对于Java中main函数为什么是静态的?

这是因为JVM在底层对于main函数的加载就是使用了静态的,换句话说就是静不静态都是可以的,这个是取决于JVM的(对于JVM的我们后续文章详解)


四 private封装

puplic与paivate两个关键字都是表示访问控制权限,

被puplic修饰的字段和方法,可以直接被类的使用者进行调用,

被private修饰的方法与字段是不可以直接被类的使用者进行调用

对于public修饰进行对象的访问前面我们已经讲解过,这里不多做赘述

下面通过具体的代码来分析一下

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.age=10;//error
        person.eat;//error
    }
}


图中标注error的是编译器报错,这个主要就是关键字private的作用了,通过private关键字进行修饰字段与方法,那么该字段与方法的作用范围只能是在当前类下,类的调用者据访问不到这些字段与方法。这个就是我们所说的private封装,封装的作用其实就是为了让代码更加的安全。


五 setter与getter

对于实现private封装的类,里面的字段我们可以通过java中提供的setter于getter方法进行访问。(注意这里是对字段进行访问,方法是不使用这个的)

class Person{
    private int age;
    private String name;
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    private void eat(){
        System.out.println("在睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(10);
        person.setName("java");
    }
}

注意这里的getter与setter方法我们是可以通过IDEA自动帮助生成,通过快捷键Alt+insert就可以进行设置,这个通过自己多动手就知道是怎样生成。

六 toString打印

与getter与setter快捷键一致,可以生成自动将对象转化为字符串的形式输出,这一过程(对象转化为字符串)我们称为序列化

  @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

@Override 在 Java 中称为 "注解“,toString 方法会在 println 的时候被自动调用。


七 构造方法(重点理解)

在前面我们讲过普通的方法,这里我们需要理解一个特殊并且很重要的一个方法,就是构造方法。构造方法在使用关键字new实例化新对象时会被自动调用,

构造方法的意义:构造对象,对象的实例化。

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果:

构造方法

class Person{
    private int age;
    private String name;
    private void eat(){
        System.out.println("在睡觉");
    }
    public Person(){//构造方法
        System.out.println("构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1=new Person("java");
        Person person2 = new Person("java",1);
    }
}

构造方法要点总结:

从以上我们可以看出构造方法不止一个,可以是多个,并且构造方法之间构成了重载。

构造方法每一个类中至少含有一个,如果自己没有写构造方法,那么编译器自动会生成一个不带任何参数的构造方法,如果自己写了构造方法,那么编译器就不会在生成不带参数的构造方法。


八 this关键字

this要注意的一点就是表示当前对象的引用,而不是当前对象,this一共有三种用法,

1 this调用当前对象的属性(this.data)

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }

    public void setAge(int age) {
        this.age = age;//this调用当前对象的属性
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

2 this调用当前对象的方法(this.func())

class Person {
    private int age;
    private String name;

    private void eat() {
        System.out.println("在睡觉");
    }
    private void sleep(){
        this.eat();//调用当前对象的方法
        System.out.println("在吃饭");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

3 this调用其他构造函数(this())

class Person {
    private int age;
    private String name;
    public Person(){
        this("java");//调用其他构造函数
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

在这里调用其他构造函数时,this的调用必须放在第一行,如果写入了两个this那么这个时候编译器就会报错,那么两个this里面只能选择一个了。要注意的是这个this()的使用情况是在一个构造方法里去调用另一个构造方法,在其他情况不能这样用。


九代码块

在这里我们主要介绍实例代码块与静态代码块,对于同步代码块后续的内容会进行阐述,而本地代码块比较简单,这里就不多加以描述。


1 实例代码块

定义:定义在类中的代码块(不加修饰符)。构造代码块一般用于初始化实例成员变量。

2 静态代码块

定义:使用static定义的代码块。一般用于初始化静态成员属性。就是在实例化代码块前加以static修饰,那么此时这个代码块就是静态代码块


3 探究两者之间的关系

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

运行结果:

静态代码块

实例代码块

不带参数的构造方法

从运行结果上去分析,我们可以看出静态代码块以及实例化代码块都比构造方法更早执行,方法是最后执行的。

class Person {
    private int age;
    private String name;
    {
        System.out.println("实例代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        System.out.println("带两个参数的构造方法");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("===========");
        Person person1 = new Person("java");
    }
}

运行结果

静态代码块

实例代码块

不带参数的构造方法

===========

实例代码块

带一个参数的构造方法

从上面这一个代码,我们可以看出静态代码块只能执行一次,而实例代码块执行与对象实例化的次数有关。

class Person {
    private int age;
    private String name;
    static int count=10;
    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果:

静态代码块

90

从以上代码可以看出静态代码是不需要通过关键字new实例化对象就能使用的,而实例化代码块是需要先实例化对象的。

class Person {
    private int age;
    private String name;

    {
        System.out.println("实例代码块");
    }
    static{
        count=90;
        System.out.println("静态代码块");
    }
    static int count=10;
}
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

运行结果:

静态代码块

10

这里对比上一个代码我们发先就是static定义的静态成员变量位置不同,导致count的值不同,说明这个count的值与static执行的顺序有关(这里要特别提一下,static后定义静态成员变量这种java的语法是支持的,不会报错)。在这里有一个特殊的例子,就是count没有初始化值,那么它的值就不与这个执行顺序有关,count就等于99,而不等于10了。


十 匿名对象

class Person {
    private int age;
    public String name;
    static int count=10;
    public void eat(){
        System.out.println("睡觉");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Person().eat();
    }
}

运行结果:

睡觉

如上代码所示,不需要通过之前那样利用person作为引用去实例化对象,直接通过关键字new创建对象就被称为匿名对象,一个对象只能用一次。


总结:

1 被private修饰的属性,需要通过java提供的setter与getter方法进行访问操作。

2 静态代码块总是最先执行的,并且只执行一次,不需要实例化对象也能执行,实例代码块执行在构造方法之前,构造方法在最后

3 在this这个关键字中,它表示的是对当前对象的引用,不是当前对象。


对于this的详细讲解可以参考以下这篇文章:

this的使用详解

目录
相关文章
|
1月前
|
安全 Java 编译器
Java对象一定分配在堆上吗?
本文探讨了Java对象的内存分配问题,重点介绍了JVM的逃逸分析技术及其优化策略。逃逸分析能判断对象是否会在作用域外被访问,从而决定对象是否需要分配到堆上。文章详细讲解了栈上分配、标量替换和同步消除三种优化策略,并通过示例代码说明了这些技术的应用场景。
Java对象一定分配在堆上吗?
|
2月前
|
Java API
Java 对象释放与 finalize 方法
关于 Java 对象释放的疑惑解答,以及 finalize 方法的相关知识。
50 17
|
1月前
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里,对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化,并探讨其背后的原理。通过实际代码示例,我们将一步步展示如何将复杂数据结构转换为字节流,以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题,以确保你的应用程序既高效又安全。
|
2月前
|
存储 Java 数据管理
Java零基础-Java对象详解
【10月更文挑战第7天】Java零基础教学篇,手把手实践教学!
30 6
|
2月前
|
Oracle Java 关系型数据库
重新定义 Java 对象相等性
本文探讨了Java中的对象相等性问题,包括自反性、对称性、传递性和一致性等原则,并通过LaptopCharger类的例子展示了引用相等与内容相等的区别。文章还介绍了如何通过重写`equals`方法和使用`Comparator`接口来实现更复杂的相等度量,以满足特定的业务需求。
28 3
|
2月前
|
存储 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第9天】在Java的世界里,对象序列化是连接数据持久化与网络通信的桥梁。本文将深入探讨Java对象序列化的机制、实践方法及反序列化过程,通过代码示例揭示其背后的原理。从基础概念到高级应用,我们将一步步揭开序列化技术的神秘面纱,让读者能够掌握这一强大工具,以应对数据存储和传输的挑战。
|
3月前
|
Java
java基础(12)抽象类以及抽象方法abstract以及ArrayList对象使用
本文介绍了Java中抽象类和抽象方法的使用,以及ArrayList的基本操作,包括添加、获取、删除元素和判断列表是否为空。
32 2
java基础(12)抽象类以及抽象方法abstract以及ArrayList对象使用
|
2月前
|
XML Java Maven
在 Cucumber 测试中自动将 Cucumber 数据表映射到 Java 对象
在 Cucumber 测试中自动将 Cucumber 数据表映射到 Java 对象
63 7
|
2月前
|
存储 Java 数据管理
Java零基础-Java对象详解
【10月更文挑战第3天】Java零基础教学篇,手把手实践教学!
26 1
|
2月前
|
Java 数据安全/隐私保护
java类和对象
java类和对象
26 5