Java—类和对象

于 2022-07-22 18:33:24 发布
阅读量430 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62824239/article/details/125929899
版权

目录

面向对象

（1）找对象
对象由类而来
类需要我们抽象
（2）创建对象

（3）使用对象

一个类可以实例化多个对象

class Person {
    //字段、属性、成员变量（类的内部，方法的外部）
    public String name;
    public int age;
    //成员方法
    public void eat(){
        System.out.println(name+"吃饭");
    }
    public void sleep(){
        System.out.println(name+"睡觉");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Person person=new Person();

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


    }

}

在这里插入图片描述

person是一个变量，不是地址，只不过这个变量，里面存储的是地址，所以这个变量，也被叫做引用。

成员变量

普通成员变量

静态成员变量

class Person {
    //普通的成员变量，属于对象
    public String name;
    public int age;
    //静态成员变量(类变量) count被放到了方法区
    public static int count;

    public void eat(){
        System.out.println(name+"正在吃饭");
    }

}
public class TestDemo2 {
    public static void main(String[] args) {
//        Person person1=new Person();
//        person1.count++;
//        System.out.println(person1.count);//1
//        System.out.println("==========");
//        Person person2=new Person();
//        person2.count++;
//        System.out.println(person2.count);//2
       
       //静态成员变量的正确访问方式
        Person.count++;
        System.out.println(Person.count);
        Person.count++;
        System.out.println(Person.count);



    }
}

在这里插入图片描述

注意事项

1.普通方法内部不能定义静态的变量

class Person {
    //普通的成员变量，属于对象
    public String name;
    public int age;
    //静态成员变量(类变量) count被放到了方法区
    public static int count;

    public void eat(){
       // static int size=0; 不能这样定义
        System.out.println(name+"正在吃饭");
    }

}

static 定义的变量是类变量，属于类的，放到方法中，会属于方法。
eat方法的调用，需要对象的引用来调用，但如果可以定义static的变量通过Person就可以调用，

2.静态方法内部不能定义静态的变量

public static void staticFunc(){
        //static int size=10; 不能这样定义
        System.out.println("static::func()");
    }

static修饰的变量是属于类的，放到静态方法中会属于方法。

总结：静态的成员变量，是不可以在方法中定义的。
3.普通方法内部可以调用静态方法

 public void eat(){
       // static int size=0; 不能这样定义
        System.out.println(name+"正在吃饭");
        staticFunc();
    }

    public static void staticFunc(){
        //static int size=10; 不能这样定义
        System.out.println("static::func()");
    }

4.静态方法内部不能定义普通方法

public void eat(){
       // static int size=0; 不能这样定义
        System.out.println(name+"正在吃饭");
        staticFunc();
    }

    public static void staticFunc(){
        //static int size=10; 不能这样定义
        System.out.println("static::func()");
        //eat(); 不能这样定义
    }

关于引用

Person  person=null;
//这个引用不指向任何对象

Person person=new Person();
Person person2=person;
//person2这个引用指向person这个引用所指向的对象

在这里插入图片描述

3.一个引用不可以同时指向多个对象
4.引用一定是在栈上吗？
肯定不是。

public class TestDemo2 {
    Person person=new Person();

    public static void main(String[] args) {
        TestDemo2 testDemo2=new TestDemo2();
        
    }

在这里插入图片描述

toString

class Person {
    //普通的成员变量，属于对象
    public String name;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 }
 public class TestDemo2 {
    public static void main(String[] args) {
        Person p=new Person();
        System.out.println(p);
    }
}

这里是引用

封装

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。

class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


}
public class TestDemo3 {
    public static void main(String[] args) {
        Person person=new Person();
        person.setName("李华");
        System.out.println(person.getName());
      

    }
}

构造方法

构造方法：方法名和类名相同，没有返回值。
构造方法是干什么的？
一个对象的产生【对象的实例化】过程
（1）为对象分配内存
（2）调用合适的构造方法

1.如果没有实现任何的构造方法，编译器会帮我们默认生成一个不带参数的构造方法，也就是说，一个类，至少会有一个构造方法。
2.如果当前类有其他的构造方法，编译器就不会帮我们生成不带参数的构造方法

package test01;
//构造方法
class Person{
    private String name;
    private int age;
    public Person(){
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name){
        this.name=name;
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;

        System.out.println("带两个参数的构造方法");
    }

}
public class TestDemo4 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println("=========");
        Person person2=new Person("名名");
        System.out.println("========");
        Person person3=new Person("小",20);


    }
}

在这里插入图片描述

  1. 构造方法构成了重载。
    方法名称相同，参数列表不同，返回值不做要求。

this

（1）this.data
调用当前对象的属性
（2）this.func()
调用当前对象的方法
（3）this()
调用当前对象的其他构造方法
this()必须放到第一行
this()必须放在构造方法当中

package test01;
//构造方法
class Person{
    private String name;
    private int age;
    public Person(){
        this("命名");//调用带有1个参数的构造方法
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name){
        this.name=name;
        System.out.println("带一个参数的构造方法");
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;

        System.out.println("带两个参数的构造方法");
    }

}
public class TestDemo5 {
    public static void main(String[] args) {
        Person person=new Person();
        

    }
}

这里是引用

代码块

实例代码快
定义在类中的代码块(不加修饰符)
静态代码块

package test01;
//代码块
class Person{
    private String name;
    private int age;

    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person(){

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

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

        System.out.println("带两个参数的构造方法");
    }

}
public class TestDemo6 {
    public static void main(String[] args) {
        Person person=new Person();
     }
}

这里是引用

package test01;
//代码块
class Person{
    private String name;
    private int age;

    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person(){

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

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

        System.out.println("带两个参数的构造方法");
    }

}
public class TestDemo6 {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println("======");
        Person person2=new Person();
    }
}

这里是引用
静态代码块只被执行了一次

package test01;
//代码块
class Person{
    private String name;
    private int age;
    public static int count;

    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person(){

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

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

        System.out.println("带两个参数的构造方法");
    }

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

上述代码说明静态代码块，不用实例化对象，都可以被执行一次。

package test01;
//代码块
class Person{
    private String name;
    private int age;
    public static int count=10;
    {
        System.out.println("实例代码块");
    }
    static {

        count=99;
        System.out.println("静态代码块");
    }
}
public class TestDemo6 {
    public static void main(String[] args) {
        System.out.println(Person.count);
    }

}

当都是静态的时候，那么和定义的顺序是有关系的
例外：当count没有初始化的时候，默认值就是99

金字塔端的蜗牛
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值