投稿
  1. 首页
  2. 随笔

Java你看【类和对象】在一起了，你也new一个对象吧

网吧增值 • 2022-11-17 • 随笔 • 阅读 8

Java你看【类和对象】在一起了，你也new一个对象吧,第1张

Java你看【类和对象】在一起了，你也new一个对象吧

目录

1、什么是类和对象

2、成员变量

2.1、类的实例化

2.2、普通成员变量

 2.3、静态成员变量

 3、类的方法

3.1、普通成员的方法

 3.2、静态成员变量的方法

 4、封装

4.1private实现封装

4.2 getter 、 seetter 方法

5、构造方法

5.1 代码举例：

5.2this的意义

6、构造代码块 

6.1实例代码块

6.2静态代码块

1、什么是类和对象

1.类就相当于一个模板，可以产生多个对象

2、在Java中使用关键字class来声明类，即创造一个新的数据类型。类在Java中属于引用类。

3、对象就是接收类的变量

 基本语法：

//创建类

class {

      field;//成员属性

      method;//成员方法

}

//实例化对象

<对象名> = ();

class为定义类的关键字， 为类的名字，{}为类的主体。

类

中的元素称为：成员属性。类中的函数称为：成员方法。

class Work {

    public int size;
    public float a;
}
2、成员变量 2.1、类的实例化

类只是一个模型一样的东西，限定了类有哪些成员变量。

一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

成员变量分为普通成员变量和静态成员变量。

2.2、普通成员变量

普通成员变量需要在main函数里new新的对象，普通成员变量可以new多个对象。

注意事项

1.使用 . 访问对象的字段

2.“访问”既包含读，也包含写

3.对于一个对象的字段如果没有设置初始值，那么会被设置一个默认的初始值

 默认潜规则

对于各种数字类型，默认值为0

对于boolean类型，默认值为false

对于引用类型（String,Array,以及自定制类），默认值为null

//类，一定是要小驼峰形式
class Person{
    public String name;//public是字段，String是属性，name是成员变量
    public int age;

}

public class ClassAndObject {
    public static void main(String[] args) {

        //对象1
        //普通成员变量需要new一个对象
        Person person1 = new Person();
        System.out.println(person1.name);
        System.out.println(person1.age);
        System.out.println("==========");


        //对象2
        Person person2 = new Person();
        person2.name = "fei";
        person2.age = 20;

        //普通成员变量的访问需要通过对象的引用来访问
        System.out.println(person2.name);
        System.out.println(person2.age);
        System.out.println("==========");

       //对象2
        Person person3 = new Person();
        person3.name = "java";
        person3.age = 15;
        System.out.println(person3.name);
        System.out.println(person3.age);

    }

}

运行结果

 2.3、静态成员变量

静态成员变量由static修饰，不需要new一个对象，可以直接调用，写法->类名.成员变量。

不像普通成员变量一样可以new多个对象从而赋予不同的值。

静态成员变量值反复使用的，输出的也是与System.out.println()接近的一个对象。

class Person{
   public static int count; //静态成员变量
}

public class ClassAndObject {

    public static void main2(String[] args) {
        //静态成员变量不需要new一个对象，
        //直接-》类名.静态的成员属性/方法
        Person.count = 1;
        System.out.println(Person.count);//1
        Person.count++;
        System.out.println(Person.count);//2

    }
}

 运行结果

 

 3、类的方法 3.1、普通成员的方法 
class Person{
    public String name;

    public void study() {

        System.out.println(name+"在学习");
    }
    public void sleep() {

        System.out.println(name+"在睡觉");
    }


}
public class ClassAndObject {
       
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "fei";

        //方法
        person.study();
        person.sleep();

    }
}

 运行结果

 3.2、静态成员变量的方法

静态方法由static修饰

静态方法属于类，而不是属于类的对象

可以直接调用静态方法，而无需创建类的实例

静态方法可以访问静态数据成员，并可以更改静态数据成员的值

在静态方法中，不可以访问非静态数据成员

class Person{
    public static String name;
    public static int count; //静态成员变量
    //类方法，就是静态成员的方法
    public static void staticFunc(){

        System.out.println("name: "+name+";"+"count = "+count);
    }

}
public class ClassAndObject {

    public static void main2(String[] args) {
    Person.count = 1;
    Person.name = "fei";

    //静态方法-》直接-》类.方法，不需要new一个对象来接收方法
    Person.staticFunc();
    System.out.println("==========");
    Person.count++;
    System.out.println(Person.name+";"+Person.count);
    }
}

运行结果

 4、封装

封装是用于管理一个软件代码的复杂程度的最基本的方法

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的，只要知道如何使用类就行了，这样就降低了类使用者的学习和使用成本，从而讲道理复杂程度。

4.1private实现封装

1.private/public 这两个关键字表示“访问权限控制”。

2.被public 修饰的成员变量或者成员方法，可以直接被类的调用者使用。

3.被private 修饰的成员变量或者成员方法，只能在当前类里面使用，不能被类的调用者使用。

4.2 getter 、 seetter 方法

getter、setter 是和 private 封装使用的，通过这两个方法的接口，可以在对象里面改变成员的赋值，不用担心类里面的成员变量的改名

 代码举例

class Person{
    //实例成员变量
    private String name;
    private int age;

   //setter、getter 方法的实现
    public void setName(String name) {
       // name = name; //不能这样写
        this.name = name;//this调用当前对象的引用
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}


public class ClassAndObject {
    public static void main(String[] args) {
        Person person = new Person();
        //方法的接口，无论类里面的成员变量怎么改名都可以直接引用
        person.setName("fei");
        String name = person.getName();
        person.setAge(21);
        int age = person.getAge();
        System.out.println("name : "+name+" ; "+"age : "+age);

    }
}

5、构造方法

方法名和类名是相同的，且构造方法比较特殊，没有返回值。

构造方法是用于一个对象的产生（对象的实例化）

{为对象分配内存，调用合适的构造方法}

注意事项：

1、如果没有实现任何的构造方法，编译器会帮我们默认生成一个不带参数的构造方法。

 2、 每个类中至少有一个构造方法

3、如果当前类有其他构造方法，那么编译器不会帮我们生成不带参数的构造方法

4.构造方法可以重载，就是方法名一样，参数的个数不一样

5.1 代码举例： 
class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person(): : 不带参数的构造方法");
    }

    public Person(String name) {
        this.name = name;
        System.out.println("Person(String): : 带1个参数String类型的构造方法");
    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person(String,int): : 带两个参数String、int 类型的构造方法");
    }

    public void show() {
        System.out.println("name : "+name+" ; "+"age : "+age);
    }
}


public class ClassAndObject {
    public static void main(String[] args) {
        Person person1 = new Person();//调用不带参数的构造方法
        person1.show();//不带有参数，所以name为初始值null, age为0；
        System.out.println("---------------");
        Person person2 = new Person("fei");//调用一个参数的构造方法
        person2.show();//age参数没带有，所以age为0；
        System.out.println("---------------");
        Person person3 = new Person("fei",21);//调用两个参数的构造方法
        person3.show();
    }
}

 运行结果：

5.2this的意义

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

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

3、this()   调用当前对象的其他构造方法，存放在构造函数当中

6、构造代码块  6.1实例代码块

构造块：定义在类中的代码块（不加修饰符）。也叫：实例代码块。构造代码块一班用于初始化实例成员。

class Person{
    private String name;
    private int age;


    {
        this.name = "WF";
        System.out.println("实例代码块");
    }

    public Person() {
        System.out.println("Person(): : 不带参数的构造方法");
    }

    public void show() {
        System.out.println("name : "+name+" ; "+"age : "+age);
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("----------------");
        person1.show();
    }
}

 运行结果

6.2静态代码块

静态代码块由 static 修饰，一般用于初始化静态成员属性

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后 , 实例代码块（构造块）执行，再然后是构造函数执行。 
class Person{
    private String name;
    private int age;
    public static int size = 10;


    {
        System.out.println("实例代码块");
    }

    static {
        size = 20;//可以改变静态初始值
        System.out.println("静态成员变量");
    }

    public Person() {
        System.out.println("Person(): : 不带参数的构造方法");
    }
}

public class ClassAndObject {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("----------------");//分割线
        System.out.println(Person.size);//静态代码块
                                        //无论静态代码块放在哪里，都是先打印静态代码块

}
    }

运行结果：

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5139220.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
网吧增值 网吧增值 一级用户组
0 0
上一篇 2022-11-17
下一篇 2022-11-17

发表评论

登录后才能评论

评论列表（0条）

保存