类和对象的学习心得

2023年5月31日10:06:22
 
 
1，
类和对象的定义：
类就是一类对象的统称。对象就是这一类具体化的一个实例。
2，类和类的实例化
用类型创建对象的过程，称为类的实例化
1.
类只是
一个
模型
一样的东西，限定了类有哪些成员
.
2.
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
创建： 
class Person{
    //成员属性
    public String name ;          //访问修饰限定符：public   private   protected  什么都不写
    public int age  ;             //name和age是实例成员变量
    public static int count;       //静态成员变量，在方法区，不管new多少个，只有一个count
    /*public boolean flg;
    public char ch;*/
    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
}

实例化：

public static void main(String[]args){
        //Person是类型  person是局部变量（属于引用类型）
         //person 1在栈上   new Person在堆上
         Person person1 = new Person();//对象的实例化
         Person person2 = new Person();
         Person person3 = new Person();
         Person person4 = new Person();
         Person person5 = new Person();
         System.out.println(person1);
         System.out.println(person2);

访问：

public static void main(String[] args) {
        Person person = new Person(); //实例化一个对象
        System.out.println(person.age);
        System.out.println(person.name);
        person.eat();

        /*System.out.println(person.flg);
        System.out.println(person.ch);
        int a;
        System.out.println(a);   */
    }

局部变量：定义在方法当中，特点是当方法结束后该变量也随之消失，因为他存储在栈上。

1.作用域：在当前方法的括号内

2.生命周期：当方法结束，方法内的局部变量也随之消失。

成员属性：（定义在类内部，方法外部的变量）

1，实例成员变量  ：age   name （在堆上）

2，静态成员变量  ：count   （在方法区）

接下来看一下如何调用：

class Person {
    //成员属性
    public String name;          //访问修饰限定符：public   private   protected  什么都不写
    public int age;             //name和age是实例成员变量
    public static int count;       //静态成员变量，在方法区，不管new多少个，只有一个count

    /*public boolean flg;
    public char ch;*/
    //成员方法
    public void eat() {
        System.out.println("吃饭");
    }

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

    public void show() {
        System.out.println("姓名：" + name + "年龄" + age);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "佐助";
        person1.show();
        System.out.println(person1);
    }

    public static void main7(String[] args) {
        Person person1 = new Person();
        person1.name = "佩奇001";
        //person2这个引用指向了person1这个对象
        Person person2 = person1;
        System.out.println(person2.name);
    }


    public static void main6(String[] args) {
        Person person1 = null;
        person1.name = "佩奇";
        System.out.println(person1.name);
    }

Alt+Insert快捷键直接生产show函数

static关键字

1，修饰成员变量：静态成员变量

2，修饰成员方法：静态成员方法

3，修饰代码块：

注意：静态的方法内部不能有实例数据成员。

原因：1.静态的方法不依赖于对象，而实例数据成员需要通过实例化才能产生（new）

2.静态的方法和静态的数据->静态的优先被执行的

public String name;          //访问修饰限定符：public   private   protected  什么都不写
    public int age;             //name和age是实例成员变量
    public static int count;  //静态成员变量，在方法区，不管new多少个，只有一个count
    // 加static是静态的
    public final int SIZE1 = 10;  //被final修饰的常量，对象，和final没关系，堆
    public static final int SIZE2 = 10;  //方法区

封装：

private实现封装 ：

class Person2{
    private String name;
    private int age;
    public void setName(String myName){
        name = myName;
    }
    public void setAge(int myAge){
        age = myAge;
    }
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Person2 person2 = new Person2();
        person2.setAge(15);
        person2.setName("卡卡西");
        System.out.println(person2.getAge());
        System.out.println(person2.getName());

    }
}

普通方法：public  返回值  方法名  （参数列表）{

方法体

}

构造方法：

前提问题：实例化一个对象分为几步？

1.为对象分配内存

2.调用合适的构造方法，才会产生一个对象。

class Person2{
    private String name;
    private int age;
    //alt+insert
    // (get and setter)快速生成
    //(Constructor)
    //this代表当前对象的引用。

    public Person2(){
        System.out.println("Person2()");
    }
    public Person2(String name){
        this.name = name;
        System.out.println("Person2(String)");
        System.out.println(this.name);
    }
    public Person2(String name,int age){
     this.name = name;
     this.age = age;
        System.out.println("Person2(String,int)");
    }

    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;
    }



    private void func4(){
        System.out.println("func()");
    }
    public void  func2(){
        func4();
    }



}


public class TestDemo2 {
    public static void main(String[] args) {
        Person2 person2 = new Person2();
        Person2 person3 = new Person2("Java");
        Person2 person4 = new Person2("鸣人",18);
    }


    public static void main1(String[] args) {
        Person2 person2 = new Person2();
        person2.setAge(15);
        person2.setName("卡卡西");
        person2.func2();
        System.out.println(person2.getAge());
        System.out.println(person2.getName());

    }
}

到此为止，下集更精彩

  • 作者：wah369
  • 原文链接：https://blog.csdn.net/wah369/article/details/109151134
    更新时间：2023年5月31日10:06:22 ，共 3667 字。