类/对象/包/static是？

#类的概念

类：是对一类有着雷同属性的对象的抽象集合，如边牧、金毛、斗牛犬，他们都属‘狗’类，有吃饭、睡觉、会摇尾巴的属性。

类的组成有成员变量（也称字段）和成员方法。类的结构：

修饰符  class(关键字) 类名{

        代码块；

}

//注意：定义一个类名采用大驼峰的定义方法：即组成类名的每一个单词的首字母采用大写形式，如StudentSystem。一个class文件最好定义一个类，且该类名与文件名相同。

#对象

对象：可以将类理解为PPT模版，我们知道它有音效、动画等功能，但却无法使用，因为我们没有将它具体化来使用，所以我们根据类来创建对象，这个过程叫做类的实例化，方法是使用new关键字来创建一个对象。自此，我们可以通过对象来给成员变量赋值，调用成员方法。

public class Student{

        int age=111;

        public void fun(){ //定义成员方法的的方法为小驼峰，即组成成员方法的单词组的第一个单词首字母为小写，其余单词的首字母为大写形式，如studentSystem。

                age=20;

               System.out.println("这是调用成员方法的结果"); 

        }

        public static void main(String[ ] args){

                 Student stu=new Student();

                  stu.fun();//stu里的age将为20，同时打印println里的内容。

}

}

##this引用

 如果成语方法出现了下列这种情况：

public class Student{

        int age=111;

        public void func(int age){

        age=age;

        }

        

        public static void main(String[ ] args){

              Student stu=new Student();

                stu.func(66);

}

结果是将成员变量的值给形参age呢，还是将形参的值给成员变量？Java定义了this引用关键字。 this引用指向的是调用该成员方法的对象，可以通过this来操作成员变量(成员方法)，注意，this只能引用该对象内的，不可引用其他对象的。

public class Student{

        int age=111;

        public void func(int age){

        this.age=age;//如此便没有歧义了。

        }

}

“this() ”可以调用构造方法,但是在一个构造方法里调用另一个构造方法，this()语句必须为第一行：

public class Test{

        int a;

        String b;

        public Test( ){

                this.a=66;

                this.b="csdn.com";

        }

        public Test(int aa, String bb){

                this();//调用上面自定义的无参构造方法。

                this.a=aa;

                this.b=bb;

        }

        public static void main(String[ ] args){

                Test te=new Test(77, "博客。"); //执行情况是先a=66, b="csdn.com"，然后a=77，b="博客。"。

        }

}

##构造方法

构造方法：编译器或用户自己定义的初始化对象中的成员变量的方法。它们满足以下规则：1.方法名必须同类名相同。2.不设置返回类型，即便书写为void。3.由编译器自动调用，仅在创建对象时调用一次。4.允许方法重载。

构造方法的实现：

#包

包：可以理解为内含许多类的文件夹，是对类和数据接口的一种管理分类方式 。也可以类比C/C++中的包含众多函数的头文件。（可以定义名字相同的两个类，前提是他们在不同的包中）。

使用import语句导入包中的类：假定我们需要JAVA语言里定义的Date类：

import java.util.Date//Date类属于util包

public class Test{

        public static void main(String[ ] args){

                Date date=new Date();//导入了Date类，便可以在Test类中创建一个Date类的对象了        

        }

}

使用import static静态导入一个类中的静态字段和静态方法： 

import static java.lang.Math.*;//导入Math类中的静态的sqrt和pow方法

public class Test{

        public static void main(String[ ] args){

                double result=sqrt(pow(3,2)+pow(2,4));        

        }

} 

#static

static：被static修饰的成员变量称为类变量或静态变量，被static修饰的成员方法称为静态方法或类方法。被static修饰的代码块称为静态代码块。它们的共同特点是：1.属于类的，而不是任何实例化的对象的。2.仅在类加载时被调用一次，无论创建多少对象都不会自动执行静态变量/方法/代码块，以后想要使用需主动调用。3.禁止在静态方法/代码块里使用非静态变量。

解释1：

public class Test{

        int a=10;

        static int b=20;

        public static void print(){

                System.out.println("这是静态的方法");

        }

        public static void main(String[ ] args){

                System.out.println(Test.a);//因为类变量属于类，所以可以不用通过对象来访问

                Test.print();//

                print();由于代码在同一个类里，所以可以直接引用print方法。

                Test te=new Test();

                System.out.println(te.a);//当然任何对象都可以使用它。

        }

}

class Test1{

        public static void main(String[ ] args){

                /*print();*/ //这里就不可以直接引用了，因为不属于print()不属于Test1类

                Test.print();//可以这样用。

}

}

解释2：

public class Test{

        public static void print(){

                System.out.print("静态方法执行了........—>"); 

        }

        static {        //静态代码块

                System.out.print("静态代码块执行了.......");        

        }      

        public static void main(String[ ] args){

                Test te=new Test();

                Test tee=new Test();

                System.out.println("主动调用静态方法......");

                Test.print();    

        }

}

/*启动调试，执行了创建对象te的代码后，结果为：静态方法执行了........—>静态代码块执行了.......，执行了创建对象tee的代码，控制台什么也不打印，因为静态成员仅执行一次。后，面手动调用print()，打印出了：静态方法执行了........-—>*/

解释3：

public class Test{

        int a;

        static void func(){

                /*System.out.println(a);这里将会编译错误*/

                Test te=new Test();

                 System.out.println(a);//以下两种方式可以使用非静态变量

                int b=66;

                System.out.println(b);      

        }

        public static void main(String[ ] args){

                func();        

}

}

附：在“{ }” 里的一段代码我们称为代码块，代码块分为普通代码块（构造方法里的）、构造代码块、静态代码块、同步代码块。这里补充构造和静态代码块的知识。

构造代码块在创建对象时默认执行，作用通常是初始化实例变量。静态代码块通常作用是初始化类变量，静态代码块仅在类加载时执行一次，但是在创建第一个对象时，这两个代码块执行级别为:静态代码块=>构造代码块，如果有多个静态和构造代码块，同级执行逻辑为定义的顺序先后。

public class Test{

        static {

                System.out.println("执行1.....—>")；        

        }

        {        //构造代码块

                System.out.println("执行3.....")； 

        }

        static {

                System.out.println("执行2.....—>")； 

        }

        public static void main(String[ ] args){

                Test te=new Test();

                /*打印结果将会是:执行1.....—>执行2.....—>执行3.....*/

}

完。