类和对象

组成结构
? 构造函数: 在创建对象的时候给属性赋值
? 成员变量:
? 成员方法(函数)
? 局部变量
? 代码块

构造器

每个类都有一个主构造器，这个构造器和类定义"交织"在一起类名后面的内容就是主构造器，如果参数列表为空的话，()可以省略
scala的类有且仅有一个主构造器，要想提供更加丰富的构造器，就需要使用辅助构造器,辅助构造器是可选的，它们叫做this def this
注意：主构造器会执行类定义中的所有语句
代码示例：

// 类默认有一个无参的主构造函数
class User { 
}

val user: User = new User

// 两个参数的主构造函数
class User2(val name: String, age: Int) { 

}
val user2 = new User2("jim", 23)
// 使用val修饰的变量默认是成员变量，对象可以访问
// user2.age   // age没有使用val或者var修饰 所以不能被访问,他不是一个成员变量，而是一个局部变量


//辅助构造器
class User3 {
   var name: String = _
   var age: Int = _
  // 辅助构造函数
  def this(name: String, age: Int) {
    // 构造函数中的首行必须调用主构造函数或者其他构造函数
    this()
    this.name = name
    this.age = age
  }
  // 辅助构造函数
  def this(msg: String) = {
    // 首行调用一个构造
    this("ww", 12)
    println(msg)
  }
}
val u1 = new User3()
val u2 = new User3("")
val u3 = new User3("lisi", 23)
println(u3.name)

总结:

1. 有两类构造器：主构造器，辅助构造器
2. 构造器的定义位置：主构造器和类交织在一起，class Student2(val name: String, var age: Int)
3. 辅助构造器是一个特殊的方法，定义在类中 def this(name:String,age:Int,gender:String)
4. 辅助构造器，第一行必须调用主构造器（或者其他的辅助构造器）
5. 辅助构造器的参数不能和主构造器的参数完全一致（参数个数，参数类型，参数顺序）
6. 可以定义空参的辅助构造器，但是主构造器的参数必须进行初始化赋值
7. 作用域：辅助构造器的变量作用域，只在方法中，主构造器的作用域是类中除了成员属性和成员方法之外的所有范围（可以通过反编译查看源码）

构造器的参数说明

• 主构造函数中使用val 和 var修饰的变量为成员变量
• val 修饰的变量默认只有getter方法 一要初始化
• var 修饰的变量默认有 get和set方法 直接点属性操作 使用 _ 占位可以稍后赋值
• @BeanProperty会生成getMsg setMsg方法

成员方法/函数

在类的成员位置定义的函数或者方法是类的成员的一部分

代码块

在类或者对象中的代码块在实例化的时候会被调用

• 在类成员位置的代码块 构造代码块 每次创建对象都会执行一次
• 在object中成员位置的代码块是静态代码块 只执行一次
• 代码有返回值

object类的底层原理

package com.doit.day01.day02

//如果构造器中的变量，不加var 或者val 那他就是一个局部变量
//加了var 或者val 的话他就是一个私有的成员变量
class Student1(var id: Int, val name: String) {

  def sayHello: Unit = {
    println(name + ":你好")
  }

  val sayFunc = () => {
    println("hello:" + name)
  }
}


object Student2{
  var id: Int = 1
  //如果在成员变量的位置上给一个_作为占位符，相当于是给他赋了一个默认值啊
  var name: String =_

  def sayHello: Unit = {
    println(name + ":你好")
  }
  val sayFunc = (x:String) => {
    println("hello:" + name + x)
  }
}


object Demo01_面向对象 {
  def main(args: Array[String]): Unit = {

    Student2.sayFunc("a")

    val student1: Student1 = new Student1(1, "zhangsan")
    println(student1.name)
    println(student1.id)
    //    student1.name = "lisi"  用val 修饰的，不能修改
    student1.id = 2
    println(student1.id)

    student1.sayHello
    student1.sayFunc()
    println(Student2.name)
  }
}

java手写实现：

package com.doit;


public class Person {
    public static String getName(){
        return Person$.person.getName();
    }

    public static Integer getAge(){
        return Person$.person.getAge();
    }

    public static void setName(String name ){
        Person$.person.setName(name);
    }

    public static void setAge(Integer age ){
        Person$.person.setAge(age);
    }
}

class Person$ {
    //自己的对象
    public static Person$ person ;
    //成员变量
    private String name;
    private int age;

    static {
        person  = new Person$();
    }

    private Person$() {
    }

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


class Test{
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        String name1 = person.getName();
        Integer age1 = person.getAge();
        System.out.println(name1);
        System.out.pr