类和对象部分知识总结

1.类和对象基础知识

class Person{      //创建一个Person类（型）
    //以下为成员属性
    public int age;    //实例成员变量
    public String name;
    public static int count;   //静态成员变量
    public final int SIZE=10;   //final是常量的意思  是对象，在堆上
    public static final int SIZE1=10; //有static修饰，在方法区

    //以下为成员方法
    public void eat(){     //非静态方法
        int a=10;   //局部变量，栈上，方法结束后变量随之消失，要进行初始化
        System.out.println("吃饭");
    }

    public static void fun(){   //静态方法，内部不能调用实例成员方法，不能对实例数据成员初始化
       count =10;
        System.out.println("静态方法");
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Person person1=new Person();//对象的实例化
        person1.age=10;
        System.out.println(person1.age);
        person1.eat();
        Person.fun();//静态的方法通过类名访问，不依赖对象
        System.out.println(Person.count);
        System.out.println(Person.SIZE1);//属于类本身，通过类访问
        Person person2=new Person();
        person2.name="sy";
        System.out.println(person2.name);
        System.out.println(person2.SIZE);

    }
}

运行结果
使用 类名. 成员访问对象的字段时，“访问” 既包含读, 也包含写，如果没有显式设置初始值, 那么会被设置一个默认的初始值。
默认值规则：
对于各种数字类型, 默认值为 0.
double 0.0
float 0.0f
long 0L
对于 boolean 类型, 默认值为 false,
对于引用类型(String, Array, 以及自定制类), 默认值为 null
普通成员方法依赖对象，内部不能定义静态成员变量，静态的具有优先级
静态变量就不能在方法内部进行定义，不论是普通的还是静态方法
静态的只能定义成成员变量

2.重写方法（toString)
在类内部 光标位置alt+insert
如果insert和delete重合，就fn,alt,insert 三个键一起按下

class Person{      
    public int age; 
    public String name;
    public static int count;  
    public final int SIZE=10;   
    public static final int SIZE1=12;
   
    public void eat(){    
        int a=10;  
         count =5; 
        System.out.println("吃饭");
    }

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

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

public class TestDemo{
    public static void main(String[] args) {
        Person person=new Person();
        person.age=10;
        System.out.println(person.age);
        person.eat();
        Person.fun();
        System.out.println(Person.count);
        System.out.println(Person.SIZE1);
        System.out.println(person);  
        System.out.println(person.name);
    }
}

运行结果
无重写函数会打印这个 @后面时是地址的哈希值
*3.setter and getter *

class Person{
    private int age;   //类外不可以访问private修饰的属性或者方法
    private String name;

    public String getName() {
        return this.name;
    }

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

    public int getAge() {
        return this.age;
    }

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

public class TestDemo{
    public static void main(String[] args) {
Person person=new Person();
person.setAge(4);
        System.out.println(person.getAge());
        person.setName("ad");
        System.out.println(person.getName());
    }
}

4.构造方法
先为对象分配内存，再调用合适的构造方法，才会产生一个对象
支持重载
this 代表当前对象的引用
静态方法的内部不能用this

class Person{
    private int age;
    private String name;

  public Person(){   //不带有参数的构造方法
      System.out.println(1);
  }
public Person(String name){  //带有一个参数的构造方法
    this.name = name;
    System.out.println(this.name);
}
    public Person(int age, String name) {     //用alt+insert
        this.age = age;
        this.name = name;
        System.out.println(this.age);
        System.out.println(this.name);
    }
}

public class TestDemo{
    public static void main(String[] args) {
        Person person=new Person();  //调用不带有参数的构造方法
        Person person1=new Person("s");
        Person person2=new Person(5,"se");
    }
}

编译器会默认给一个不带参数的构造方法

5.this关键字
this.data 当前对象从成员
this.func() 当前对象的方法
this() 调用当前的构造方法，必须放在第一行，只能调一个

class Person {
    private int age;
    private String name;

    public Person() {
        this("RT");  //调用带有一个参数的构造方法
        System.out.println(1);
    }

    public Person(String name) {
        this.name = name;
        System.out.println("f");
        System.out.println(this.name);
    }

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

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

运行结果

class Person{
    public int age;
    public String name;

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

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

本文地址：https://blog.csdn.net/yanweiding/article/details/109261938