一、类的创建及初始化
类通常是一类事物的抽象，如人就是一个类，你、我、他是这个类的具体实例，也就是对象。在Java中我们可以通过形如：
class A {}来创建一个类，我们说过Java是面向对象的语言，每个对象都应该拥有它自己的属性和方法，就拿人来说，肤色、身高等是人的属性，吃、喝、玩等都是方法，也就是说属性描绘了类的特点，而方法描述了类的功能，体现在Java的类中就像下面的代码这样：
class People{
private int age;
eat();
}
在面向对象的思想中，一切皆对象，我们以对象为单位进行编程，将这个对象所有的属性方法包装在一起，就是封装。一般情况，我们通过类的
构造器来
创建类对象，构造器是一个拥有和类名同样的名字的方法，我们可以对它传递参数，进行一些初始化工作，如，当我们需要在
创建对象的时候，初始化其姓名及年龄，我们 可以这样来做：
class People{
private name;
private age;
public People(String name,int age){
this.name=name;
this.age=age;
}
}
测试类：
public class Test{
public static main(String[] args){
People person=new People("skx",28);
}
}
new
caozuofu.html" target="_blank">操作符会为我们在
内存中开辟空间(后面会详细讲解
堆栈内存)，person是对象名，也是引用，在栈上分配，指向由new在堆上分配的内容，具体由
JVM内存管理，这里不深讲。我们再来分析一下这个过程：当调用new Person()时，编译器首先检查下原类Person中是否有Person()构造方法，此处因为有public Person(String name,int age)，所以new的时候，直接调用的该方法，但是很多时候，我们并没有显示声明构造方法，此时，编译器在调用的new Person()的时候，会自动为我们的Person类添加一个无参的空Person()构造方法：Person(){}，来执行类的构造过程。
&&:变量无论放在什么地方，都会先于任意一个方法的执行前执行，包括构造方法，而构造方法是一个类(创建时)必须会执行的方法，不需要显示的进行调用。同时，不论变量在哪儿分布，只要在方法外部，就一定先于方法初始化。
public class Person {
public Person(int id) {
System.out.println("person(" + id + ")");
}
//
静态方法优先于普通方法(赋值，实例是普通方法);
public static void main(String[] args) {
Build b = new Build();
}
}
class Build {
//p1是Build的属性，优先于构造方法Build()执行，将执行Person(1);
Person p1 = new Person(1);
public Build() { //在这里，将最后执行
System.out.println("this is build's block!");
Person p2 = new Person(2);
}
//p3是Build的属性，优先于构造方法Build()执行,将执行Person(3);
Person p3 = new Person(3);
}
另一个关键的知识点静态块和非静态块。二者都有很简单的声明方式，只需一对大括号{}就行，静态块的话，在前面加static
关键字，我们写个小程序来看看：
public class Person {
/*静态块，与主静态方法依顺序执行，只执行一次*/
static{
System.out.println("this is static block!");
}
/*非静态块,执行2次*/
{
System.out.println("this is non-static block!");
}
public Person(int id) {
System.out.println("person(" + id + ")");
}
public static void main(String[] args) {
Person p1 = new Person(1);
Person p2 = new Person(2);
}
}
该程序输出：
this is static block!
this is non-static block!
person(1)
this is non-static block!
person(2)&&：静态块是在类装载时执行的（编译成.class文件，第一次被调用、应用时），且只执行一次。而非静态块是在调用构造方法之前执行的，每生成一个实例对象，就会调用一次非静态块。
Java代码 收藏代码
class A{
static{
System.out.println("1111");
}
{
System.out.println("3333");
}
static void print(){
System.out.println("jjjjjjj");
}
}
public class
Extends extends A{
public static void main(String[] args){
System.out.println("22");
}
}
输出结果：
1111
22
这里没有调用A的
构造函数，只是对A.class进行了加载，所以只运行A的静态块；而静态方法[实例调用才会执行]和非静态块[也需要实例调用时执行]没有被执行。
此处，我想引入一个很重要的知识点：static关键字。一般来说，被声明为static的变量或者方法，或者前面说的块，都属于静态属性、静态方法(有时称：类属性、类方法)，属于类级属性（想象为类的原型属性，在方法区分配内存）。如静态块一样，其它的静态属性也具有这个特点：初始化只在类装载的时候执行一次。对于类变量和类方法，还有一个重要的特点就是，外部对象对
他们的引用可以直接通过类名来调用。
除了使用new操作符，我们还有一些其它方法来创建类，如Java的
反射机制，后面会有专门的文章来介绍相关的知识点。
public class A{
public static void main(String[] args){
A a=new A();
]
}
主方法可以放在在其他任意类中，可以
理解为主方法在另外一个class B中定义的，要调用A的属性，先声明创建A实例；
总体来说执行顺序为：静态块，静态属性->非静态块，属性->构造器;对于静态块和静态属性或者非静态块和属性，
初始化顺序决定于它们在代码中的顺序。
接下来我们分析一下类的属性和方法
属性：
类中的属性一般分为类属性（静态属性）、实例属性（
全局变量）、局部属性（局部变量）。
类属性：前面已经说过就是那些声明为static的属性，在整个过程中只进行一次初始化，在内存中只开辟一个空间，不论在哪儿调用，值保持一致。一旦被修改，所有引用它的地方都会跟着修改。一般直接通过类名进行调用。
实例属性：
实例变量是可以不进行初始化(只声明)，比如一个整型没有初始化，则默认值为0，String为null；而局部变量假如不赋初值语法上是通过的，但是在使用这个变量是程序就报错了。基本数据类型在栈中分配内存，引用数据类型在堆栈中都分配内存，在堆当中分配的是对象本身，而栈中则是对这个对象的引用。
局部属性：局部变量是在方法内部声明的变量，生命期仅在方法内，方法结束后变量就消失了；局部变量必须初始化再使用，否则会报错,也就是说，
假如你在方法内定义了一个局部变量，并且没有赋值，那么你在使用这个变量的时候一定得赋值，不然就报错了。同时，局部变量可屏蔽全局变量。
方法：
方法就是类的行为，形如：public void say(){
dosomething...};由方法头和方法体构成，方法头包括：访问控制符（如public private等）、返回类型（取决于方法返回
值类型）、方法名、参数列表组成。声明为void的方法，返回值为空。在特殊的情况 下，我们可以为方法添加一些特殊的关键字以实现特殊的功能，如synchronized、final、static、abstract等等。两个重要的方面：
重载（Overload）和重写（Override也称覆写）。
重载：
是指在同一个类中，具有相同的方法名，不同的参数列表的方法之间的一种机制。参数列表的不同体现在：类型不同、个数不同、顺序不同，只要满足任一一个，就可以进行方法重载。
若用同一个方法名print，
同步传入不同的参数，实现不同的功能，这就是方法重载，用这样的机制有什么好处？个人感觉就是在模型上的一种统一，同样的功能，调用同样的方法，只需传入不同的参数，增强了程序的可读性和易于维护，当有很多个功能相似的方法的时候，如果我们为多个方法只设计了一个名称，想通过名称来区分它们的话，会很糟糕，而且会让人觉得程序的可读性差，设计不够巧妙！此处问题来了：我们可不可通过方法的返回值来区别方法重载？
&&：当调用两个不同返回类型，其他参数相同的方法时，并不会先得到他们的返回值，返回值只有在方法执行完毕才返回，在调用之初，编译器无法判断他们的区别，所以只能当同名方法来处理：报错！所以试图通过返回值来进行方法重载是不正确的！
重写：
重写是在继承中存在的，在两个类（子类和父类之间存在的关系）中，子类重写父类的方法，方法名相同，参数也相同的一种机制。
当子类继承了父类后，想对父类的方法功能进行扩展，就可以使用重写，这样做的目的就是：当
你需要扩展新的功能的时候，不需要新建方法，在父类的方法中进行补充，这样一种面向对象思维的体现，不用重写同样可以达到这样的效果，但是用了重写更加符合OO思想。子类覆写父类方法，才能被识别;
&&：向上转型时，被覆写的方法，子类的方法优先于父类方法执行，但是，父类的属性不受影响！(详见后面的继承)
不定参数方法
有的时候，我们不能确定方法的参数个数，我们可以采取这种机制(String ... args)或(String[] args)，如下面的代码：
Java代码 收藏代码
public class Extends {
public static void print(String...args){
for(int i = 0;i<args.length;i++){
System.out.print(args[i]+" ");
}
}
public static void main(String[] args){
print("sd","ew","we","dd");
}
}
相关文章
