对象

public class CarDemo {

    public static void main(String[] args) {
        // 在计算机中创建一个car的实例,通过new关键字.
        Car c = new Car(); // c 就是 一个类类型的引用变量,指向了该类型的对象.
        c.num = 4;
        c.color = "red";
        c.run(); // 要使用对象中的内容可以通过 对象.成员 的形式来完成调用

        /*
         * 匿名对象,没有名字的对象.
         * new Car(); //匿名对象,其实就是定义对象的简写格式.
         * 
         * Car c = new Car();
         * new Car().run();
         * 
         * 1.当对象对方法仅进行一次调用的时候,就可以简化成匿名对象.
         * 2.匿名对象可以作为实际参数进行传递.
         */
        Car c1 = new Car() ;
        Car c2 = new Car() ;
        show(c1);
        show(c2);
        show(new Car()) ;
    }

    public static void show(Car c) { //类类型的变量一定指向变量,要不就是null
        c.num = 3;
        c.color = "black";
        System.out.println(c.num+"..."+c.color);

    }
}

class Car {

    int num = 6;
    String color;

    void run() {
        System.out.println(num + "..." + color);
    }
}

import com.sun.org.apache.regexp.internal.recompile;

public class ConsDemo {

    /*
     * 构造函数:构建创造对象时调用的函数.
     * 作用:可以给对象进行初始化.
     * 创建对象都必须要通过构造函数初始化.
     * 一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数.
     * 如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了.
     * 
     * 一般函数和构造函数有什么区别?
     *构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化. 
     *一般函数:对象创建后,需要函数功能时才调用.
     *
     *构造函数:对象创建时,会调用且只调用一次.
     *一般函数:对象创建后,可以调用多次.
     *
     *什么时候定义构造函数呢?
     *在描述事物时,该事物已存在就具备的一些内容,这些内容都定义在构造函数中.
     */
    public static void main(String[] args) {
//      Person_2 p = new Person_2() ; 
//      p.speak();
//      Person_2 p1 = new Person_2("旺财") ;
//      p1.setName("王娅");
//      p1.speak();
//      Person_2 p2 = new Person_2("小强", 10) ;
//      p2.speak();
        Person_2 p1 = new Person_2("aa",30) ;
        Person_2 p2 = new Person_2("bb",40) ;
    }


}

class Person_2{
    private String name ;
    private int age ;

    //定义一个Person类的构造函数.
    Person_2() {    //构造函数,而且是空参数的.
        name = "baby" ;
        age = 1; 
        System.out.println("person run");
    }

    Person_2(String n) {
        name = n; 
    }

    Person_2(String n,int a) {
        name = n; 
        age = a ;
    }

    public void speak() {
        System.out.println(name+":"+age+"岁");
    }

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

public class MainDemo {

    /*
     主函数特殊之处:
     1.格式是固定的.
     2.被jvm所识别和调用.

     public:因为权限必须是最大的.
     static:不需要对象的.直接用主函数所属类名调用即可.
     void:主函数没有具体的返回值.
     main:函数名,不是关键字,只是一个jvm识别的固定的名字.
     String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型.
     */
    public static void main(String[] args) {

        System.out.println(args);   //[Ljava.lang.String;@3781efb9
        System.out.println(args.length);

        for(int x = 0; x<args.length; x++) {
            System.out.println(args[x]);
        }
    }
}

public class PersonDemo {

    public static void main(String[] args) {
        Person p = new Person();
//      p.age = -20 ;
        p.setAge(20);
//      p.speak();
    }
}

class Person {
    private int age; // 私有

    void speak() {
        System.out.println("age=" + age);
    }

    public void setAge(int a) {
        if (a > 0 && a < 130) {
            age = a;
            speak();
        } else {
            getAge() ;
        }
    }

    public int getAge() {
        System.out.println("输入错误,请重新输入!!!");
        return age ;
    }

    /*
    public void input(int a) {
        if (a > 0 && a < 130) {
            age = a;
            speak();
        } else {
            System.out.println("输入错误!");
        }
    }
    */
}

/*
静态代码块:
随着类的加载而执行.而且只执行哦一次,

作用:
   用于给类进行初始化.
 */
public class StaticCodeDemo {


    public static void main(String[] args) {
//      new StaticCode().show();
//      new StaticCode().show();
//      StaticCode.show

        Person_5 p1 = new Person_5() ;
        p1.speak();
        Person_5 p2 = new Person_5("旺财") ;
        p2.speak();
    }

}

class StaticCode {
    static int num ;
    static  {
        num = 10 ;
        System.out.println("hellow");
    }

    static void show() {
        System.out.println(num);
    }
}

class Person_5{

    private String name ;

    {   //构造代码块,可以给所有对象进行初始化.
//      System.out.println("person run");
        cry() ;
    }

    Person_5() {    //构造函数是给对应的对象进行针对性的初始化.
        name = "baby" ;
    }

    Person_5(String name) {
        this.name = name ;
    }

    public void speak() {
        System.out.println("name:"+name);
    }

    public void cry() {
        System.out.println("哇哇");
    }   
}

public class StaticDemo {

    public static void main(String[] args) {
        Person_4 p = new Person_4();
        p.setName("小强");
        p.show();
    }
}

/*
static的特点:
1.static是一个修饰符,用于修饰成员.
2.static修饰的成员被所有的对象所共享.
3.static优先于对象存在,因为static的成员随着类的加载就已经存在了.
4.static修饰的成员多了一种调用方式,就是可以直接被类名所调用.  类名.静态成员
5.static修饰的数据是共享数据,对象在存储的是特有数据.
 */
class Person_4 {
    private String name;    //成员变量,实例变量
    static String country = "CN";   //静态变量,类变量

    public void show() {
        System.out.println(Person_4.country + ":" + this.name);
    }

    public String getName() {
        return name;
    }

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

}


/*
静态什么时候用?
1.静态变量:  
    当分析对象中的成员变量的值都是相同的,这时这个成员就可以被静态修饰.
    只要成员变量的值在对象中是不同的,就是对象的特有的值.必须存储在对象中,是非静态的.
    如果成员变量的值在对象中的值是相同的,对象不需要修改值,只需要使用即可,不需要存储在对象中.
就定义成静态的.    
2.静态函数:
    函数是否用静态修饰,就参考一点.就是该函数功能是否有访问到对象中的特有数据.
    简单说,从代码看,该功能是否需要访问非静态的成员变量.如果需要,该功能就是非静态的.
如果不需要,就可以将该功能定义成静态的.当然,也可以定义为非静态.但是非静态需要被对象调用,
如果创建对象仅仅只调用函数而不需要访问特有数据,该对象的创建没有意义.
 */
public class StaticDemo2 {

    public static void main(String[] args) {

    }

}

class Demo {
    int num = 9 ;
}


public class ThisDemo {

    public static void main(String[] args) {
        Person_3 p1 = new Person_3("张三", 30);
        Person_3 p2 = new Person_3("李四",40);
        p2.compare(p1) ;
    }
}

/*
 * 当成员变量和局部变量重名,可以用关键字 this 来区分. this:代表当前对象. this就是所在函数所属对象的引用.
 * 简单说:那个对象调用了this所在的函数,this就代表哪个对象.
 * this也可以用于在构造函数中调用其他构造函数.
 * 注意:只能定义在构造函数的第一行,因为初始化动作要先执行.
 */
class Person_3 {
    private String name;
    private int age;

    Person_3() {    //构造函数,而且是空参数的.
        name = "baby" ;
        age = 1; 
        System.out.println("person run");
    }

    Person_3(String name) {
        this.name = name; 
    }

    Person_3(String name, int age) {
        this(name) ;
        this.age = age;
        /*
        if(this.age < 1) {
            System.out.println("输入错误,请重新输入!!!");
            return ;
//      }else if(this.age == 0){
//          System.out.println("输入错误,请重新输入!!!");
//          return ;
        }else{
            this.speak();           
        }
        */
    }

    /*
     * 判断是否是同龄人.
     */
    public boolean compare(Person_3 p) {
        /*
        if(this.age == p.age) {
            System.out.println("true");
            return true ;
        }else{
            System.out.println(false);
            return false ;
        }
        */

        return this.age == p.age ;
    }

    void speak() {
        System.out.println(this.name + ":" + this.age + "岁");
    }
}