Java 类的构造函数<二>

package com.fish.object;
/*
描述一个员工类，员工具备 的属性：id\ name \ age 。
具备的公共行为： 工作。 
要求：一旦创建一个员工对象 的时候，那么该员工对象就要对应 的属性值。
*/
class Employee{
    int id;  //编号
    String name;  //名字
    int age; //年龄
    
    //构造函数
    public Employee(int a, String b , int c){
        id =a;
        name = b;
        age = c;
    }
    public void work(){
        System.out.println(name+"好好工作，努力挣钱!!");
    }
}

class Demo3{
    public static void main(String[] args){
        //创建一个员工对象
        Employee e = new  Employee(110,"狗娃",20);
        System.out.println("编号："+ e.id+" 名字："+e.name +" 年龄："+ e.age);
    }
}

package com.fish.object;
/*
 构造代码块：
 构造代码块的作用：给对象进行统一的初始化。new 对象的时候执行,构造代码块在外部不能操作，只能定义类的时候事先设置好动作
 构造函数的作用： 给对应的对象进行初始化。
 构造代码块的格式：
 {
  构造代码块
 }
 注意： 构造代码块的大括号必须位于成员 位置上。方法之外，类里面
 
 代码块的类别：
 1. 构造代码块。
 2. 局部代码块. 大括号位于方法之内。作用：缩短局部变量的生命周期，节省一点点内存。
 3. 静态代码块  static 
 */
 
 
class Baby {
    int id; // ***
    String name; // 名字
    
    // 构造代码块...
    {
        System.out.println("构造代码块的代码执行了......");
    }
    // 带参构造函数
    public Baby(int i, String n) {
        id = i;
        name = n;
    }
    // 无参构造方法
    public Baby() {
    }
    public void cry() {
        System.out.println(name + "哇哇哭...");
    }
}
class Demo4 {
    public static void main(String[] args) {
    
    {  //局部代码块
        Baby b1 = new Baby(110, "狗娃"); // 狗娃 狗剩 铁蛋
        System.out.println("编号：" + b1.id + " 名字：" + b1.name);
    }
    /*
     * System.out.println("编号："+ b1.id + " 名字："+b1.name);
     * 
     * new Baby(112,"狗剩"); new Baby();
     */
    /*
     * new Baby(110,"狗娃"); new Baby(112,"狗剩"); new Baby();
     */
    }
}

package com.fish.object;
/*
 构造代码块要注意的事项：
 1. java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。 
 2. 成员变量的初始化工作其实都在在构造函数中执行的。
 3. 一旦经过java编译器编译后，那么构造代码块的代码块就会被移动构造函数中执行，是在构造函数之前执行的，构造函数的中代码是最后执行 的。
 4. 成员变量的显示初始化与构造代码块的代码是按照当前代码的顺序执行的。
 */
class Demo5 {
    // 构造函数
    public Demo5() { // 构造函数
        i = 300000000;
    }
    // 构造代码块 //构造代码块的初始化
    {
        i = 200000000;
    }
    int i = 100000000; // 成员变量的显初始化
    public static void main(String[] args) {
        Demo5 d = new Demo5();
        System.out.println("i = " + d.i); 
    }
}

package com.fish.object;
/*
 需求： 使用java类描述一个动物。
 问题：存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是就近原则的机制访问的。)。
 this关键字：
 this关键字代表了所属函数的调用者对象。
 this关键字作用：
 1. 如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
 2. 在一个构造函数中可以调用另外一个构造函数初始化对象。
 this关键字调用其他的构造函数要注意的事项：
 1. this关键字调用其他的构造函数时，this关键字必须要位于构造函数中 的第一个语句。
 2. this关键字在构造函数中不能出现相互调用 的情况，因为是一个死循环。
 3. this 在new 创建对象后才能确定，相当于晚绑定
 this关键字要注意事项：
 1. 存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是“就近原则”的机制访问的。)
 2. 如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的 前面添加this关键字。
 */

class Animal {
    String name; // 成员变量
    String color;
    public Animal(String n, String c) {
        name = n;
        color = c;
    }
    // this关键字代表了所属函数的调用者对象
    public void eat() {
        System.out.println("this:"+ this);
        String name = "老鼠"; // 局部变量
        System.out.println(this.name + "在吃..."); // 需求： 就要目前的name是成员变量的name.
    }
}
class Demo6 {
    public static void main(String[] args) {
        Animal dog = new Animal("狗", "白色"); // 现在在内存中存在两份name数据。
        Animal cat = new Animal("猫", "黑色");
        cat.eat();
    }
}

package com.fish.object;
/*
 this关键字调用其他的构造函数要注意的事项：
 1. this关键字调用其他的构造函数时，this关键字必须要位于构造函数中 的第一个语句。
 2. this关键字在构造函数中不能出现相互调用 的情况，因为是一个死循环。
 */
class Student {
    int id; // ***
    String name; // 名字
    // 目前情况：存在同名 的成员 变量与局部变量，在方法内部默认是使用局部变量的。
    public Student(int id, String name) { // 一个函数的形式参数也是属于局部变量。
        this(name); // 调用了本类的一个参数的构造方法
        //this.name=name; //代码重复了
        // this(); //调用了本类无参的 构造方法。
        this.id = id; // this.id = id 局部变量的id给成员变量的id赋值
        System.out.println("两个参数的构造方法被调用了...");
    }
    public Student() {
        System.out.println("无参的构造方法被调用了...");
    }
    public Student(String name) {
        this.name = name;
        System.out.println("一个参数的构造方法被调用了...");
    }
}
class Demo7 {
    public static void main(String[] args) {
        Student s = new Student(110, "铁蛋");
        System.out.println("编号：" + s.id + " 名字：" + s.name);
        /*
         * 
         * Student s2 = new Student("金胖子"); System.out.println("名字：" + s2.name);
         */
    }
}

package com.fish.object;
/*
需求： 使用java定义一个人类，人具备 id、name 、 age三个属性， 还具备一个比较年龄的方法。
要求： 必须 要 写上构造函数，构造函数也必须要使用上this关键字。
*/
class Person{
    int id; //编号
    String name; //姓名
      
    int age;  //年龄
    //构造函数
    public Person(int id,String name ,int age){
        this.id  = id;
        this.name = name;
        this.age = age;
    }
    //比较年龄的方法
    public void compareAge(Person p2){
        if(this.age>p2.age){
            System.out.println(this.name+"大!");
        }else if(this.age<p2.age){
            System.out.println(p2.name+"大!");
        }else{
            System.out.println("同龄");
        }
    }
}
class Demo8{
    public static void main(String[] args) 
    {
        Person p1 = new Person(110,"狗娃",17);
        Person p2 = new Person(119,"铁蛋",9);
        p1.compareAge(p2);
        //p1.compareAge(p1,p2); //这样完全没有必要
    }
}

package com.fish.object;
/*
static(静态)
需求：描述一下学生类。  都是中国人....
目前存在的问题： 所有的学生都是中国 的，有n个学生就会有n份中国的 数据存内存中，这样子
会浪费内存。
目前方案： 把“中国”这个数据移动 到数据共享区中，共享这个数据给所有的Student对象使用即可。
问题2： 如何才能把这个数据移动 到数据共享区中共享呢？
解决方案： 只需要使用static修饰该数据即可。
静态的成员变量只会在数据共享区中维护一份，而非静态成员变量的数据会在每个对象中都维护一份的。。
*/

class Students{
    String name;
    //使用了static修饰country，那么这时候country就是一个共享的数据。
    static String  country  = "中国";//国籍
    //构造函数
    public Students(String name){
        this.name = name;
    }
}
class Demo9 {
    public static void main(String[] args) 
    {
        Students s1 = new Students("张三");
        Students s2 = new Students("陈七");
        s1.country = "小日本"; //静态变量是全局的，修改一个，影响所有
        System.out.println("姓名："+s1.name+" 国籍："+ s1.country); //  中国   
        System.out.println("姓名："+s2.name+" 国籍："+ s2.country); // 小日本
    }
}

package com.fish.object;
/*
static(静态\修饰符)
1. static修饰成员变量 ：如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰。
静态成员变量的访问方式：
方式1： 可以使用对象进行访问。
格式： 对象.变量名。
方式二： 可以使用类名进行访问。
格式： 类名.变量名;
注意： 
1. 非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。
2. 千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据是真正需要被共享的时候
才使用static修饰。
static修饰成员变量的应用场景： 如果一个数据需要被所有对象共享使用的时候，这时候即可好实用static修饰。
2. static修饰成员函数:

*/
class Student2{
    staticString name;  //非静态成员变量
    staticString  country  = "中国";  //静态的成员变量
    public Student2(String name){
        this.name = name;
    }
}
class Demo10 {
    public static void main(String[] args){
    Student2 s1 = new Student2("狗娃");
    Student2 s2 = new Student2("狗剩");
    
    //System.out.println("国籍："+ Student.country);
    System.out.println("名字："+ s1.name);
    System.out.println("名字："+ s2.name);
    
    }
}

package com.fish.object;
/*
需求：统计一个类被使用了多少次创建对象，该类对外显示被创建的次数。
*/
class Emp{
    //非静态的成员变量。
    staticint count = 0;//计数器
    String name;
    
    //构造代码块
    {
        count++;
    }
    public Emp(String name){
        this.name = name;
    }
    public Emp(){  //每创建一个对象的时候都会执行这里 的代码
    }
    
    public void showCount(){
        System.out.println("创建了"+ count+"个对象");
    }
}

class Demo11{
    public static void main(String[] args){
        Emp e1 = new Emp();
        Emp e2 = new Emp();
        Emp e3 =new Emp();
        e3.showCount();
    }
}

/*
构造函数：
构造函数的作用：初始化对应的对象。
构造函数的格式：
    修饰符  函数名(形式参数){
        函数体
    }
构造函数要注意的事项：
    1. 构造函数是没有返回值类型的。
    2. 构造函数的函数名是必须与类名一致。
    3. 构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用
    对应 的对象。
    4. 如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参 的构造函数。
    5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参 的构造函数。
    6. 构造函数是可以以函数重载的形式存在多个。
    
构造代码块：
构造代码块的作用：给对象进行统一的初始化。
构造代码块的格式：
{
    代码；
}
构造代码块是在创建了代码块所属类的对象时调用一次。
this关键字：
this关键字代表了所属函数的调用者对象。
this关键字的作用：
    1. 一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部 变量的，可以通过this关键字指定访问成员变量 的数据。
    2. this关键字还可以在构造函数中调用另外一个构造函数初始化对象，
this关键字调用构造函数要注意的事项：
    1. this关键字调用其他 的构造函数时，必须要是在第一个语句。
    2. this关键字调用构造函数时不能出现相互调用，因为是一个死循环。
    3. 如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。

static（静态、修饰符）
static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.

静态成员变量的访问方式：
方式一： 使用对象进行访问。
    对象.属性名
方式二：可以使用类名进行访问。
    类名.属性名
注意：
1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。
2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。
*/

class Demo1{
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

本文出自 “小鱼的博客” 博客，谢绝转载！