java面向对象基本知识

1.构造方法

构造方法特征：
      每个类中默认有一个无参的构造方法
      构造方法必须与类名相同
      构造方法没有返回值，也不需要void修饰
      如果一个类中定义有参的构造方法，默认无参的构造方法就会被覆盖，需要显式的定义出来

 构造方法作用：
      主要用来为创建的对象进行初始化
      成员变量默认值，就是在无参构造方法中赋值
  
 方法重载：
     在一个类中，有多个名称相同的方法
     当出现多个方法名相同时，可以通过参数个数，类型，顺序区分所调用的方法
     普通的成员方法也可以进行方法重载

下面是运行实例代码：

import org.omg.PortableInterceptor.ServerRequestInfo;

public class person {
    String name;
    int age;
    String gender;//性别




    /*
    构造方法特征：
          每个类中默认有一个无参的构造方法
          构造方法必须与类名相同
          构造方法没有返回值，也不需要void修饰
          如果一个类中定义有参的构造方法，默认无参的构造方法就会被覆盖，需要显式的定义出来

     构造方法作用：
          主要用来为创建的对象进行初始化
          成员变量默认值，就是在无参构造方法中赋值


      方法重载：
           在一个类中，有多个名称相同的方法
           当出现多个方法名相同时，可以通过参数个数，类型，顺序区分所调用的方法

           普通的成员方法也可以进行方法重载
     */
    public person(){
        System.out.println("Person默认的无参构造方法");
        age = 0;
        name = null;
        gender = null;
    }

    public person(int age,String name,String gender){
        System.out.println("Person有参的构造方法");
        age = 20;
        name = "开心";
        gender = "男";
    }
    public person(String name, int age,String gender){
        System.out.println("Person有参的构造方法");
        name = "开心";
        age = 20;
        gender = "男";
    }
    public person(String name, int age){
        System.out.println("Person有参的构造方法");
        name = "开心";
        age = 20;
    }
    public  void  eat(){
        System.out.println("吃饭");
    }
    public  void drink(){
        System.out.println("喝水");
    }
    public  void  study(){
        System.out.println("学习");
    }
}

此处为测试代码：

（代码运行均使用的是idea）

import day2.demo1.person;

public class test {
    public static void main(String[] args) {
        person p1 = new person(20,"牛马","中性");
        new person(20,"开心","男");

    }
}

接下来就是了解面向对象的运行逻辑

 步骤：

1.启动main方法,main就被加载到栈空间中.
2.new Person() 把Person.class文件加载虚拟机内存中(方法区)
3.Person P1  p1只是持有对象在内存空间的地址,并不是对象本身,所以把这种变量称为引用变量
4. = 只是把堆空间中的内存地址 赋给左边的栈中的变量, 栈中的变量只是持有对对象访问的引用地址

代码实例：
 

public class Person {
    /*
    人类
    */

        String name; //姓名
        int age; //年龄
        String gender;//性别

        public Person(){

        }

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

    }

public class Test {
    public static void main(String[] args) {
  
        int[] a = new int[10];
        a[0] = 1;
        Person P1 = new Person();//1001
        P1.name = "张三";
        P1.age = 20;
        P1.gender = "男";
        P1.show();
        Person P2 =  new Person();//1002
        P2.name = "李四";
        P2.age = 21;
        P2.gender = "男";
        P2.show();
        Person p3 = P2;//只是把对象的地址赋给了p3,并没有重新创建出一个新的对象
        p3.name = "王五";

        System.out.println(P2.name);//王五
        System.out.println(p3.name);//王五
        Person p4;
        p4 =   new  Person();//p4表示的是一个对象,指向的是一个对象, 最好不要说p4就是对象
        p4.name = "";
        Person p5 = p4;

    }
}

在了解上述的运行逻辑之后

我们可以知道，所谓的 Person P1 = new Person()中，P1只是携带着对象地址的变量，并不是对象本身。

同时在传参时,参数类型为基本类型,传参时,是将自己的值赋给另一个变量.
另一个变量的值改变,不影响实参的结果

public class Demo {

    public static void main(String[] args) {
        Demo d =  new Demo();
        int x = 10;
        d.test(x);
        System.out.println(x);//10
    }

    public  void test(int a){
        a = 20;
        System.out.println(a);//20
    }
}

接下来说的便是在写代码过程中很容易遇到并且报错的一点，

同时也要用到this关键词

public class Person {
    String name;
    int age;
    public Person(){

    }
    public  Person(String name,int age){


        //this表示当前操作的对象


        this.age = age;
        this.name = name;
    }
    public void show(){

        System.out.println(this.name+" "+this.age);

    }

}

测试代码：

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("李某某",20);
        Person p2 = new Person("牛某某",21);
        p1.show();
        p2.show();
    }

}