默认构造函数都从父类object继承了无参的构造方法。
1、类在初始化实例化对象（new）的时候将默认调用的是类中的默认构造函数（即无参的构造函数）；
2、为方便初始化数据，通常会构造函数（即构造函数需要带参数，方法名与类名、无参的方法名一致，只是参数个数不一致），那么在实例化对象（new）的时候就可以使用要带参数的构造函数，以便初始化数据。
示例：
类Monitor，包含属性String height;String width
public Monitor(){} //无参的构造函数即默认构造函数，一般可不写，编译器自动创建
public Monitor(String height,String width){}
在main方法里我做初始化动作
Monitor monitor=new Monitor();//实例化时不带参数，即使在Monitor类里面带有N多个带参数的构造函数，但这种方式如果要赋值,需手动赋值，如:monitor.height=100;monitor.width=200;
Monitor monitor2=new Monitor("100","200");//这种方式是带参数的构造函数主要用来在创建对象时初始化对象 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中，特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载 1.构造函数的命名必须和类名完全相同;而一般方法则不能和类名相同. 2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的. 3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用. 4.当定义一个类的时候，通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略，编译器会提供一个默认的构造函数.此默认构造函数是不带参数的.而一般方法不存在这一特点
定义：
class A
{
public A(){}
}
使用：
A a=new A();//在这里，A()就是就是构造函数。
需要注意的一点是，如果类里面没有定义构造函数，编译器也会自动生产一个空构造函数，类的各个成员都赋上默认值。
但是如果在类里面只定义了一个私有的构造函数的时候，那么这个类将不能被实例化。
class A
{
string a;
private A() { }//这个类不能被实例化
}
如果我们定义了带参数的构造函数，而没有定义不带参数的构造函数，那么在实例化这个类的对象的时候必须提供参数。
class A
{
string a;
public A(string str) {a=str; }
}
不能这么实例化对象 A a=new A();构造函数分为动态构造函数和静态构造函数。 动态构造函数是类或结构实例化时，为其分配内存空间，完成类或结构当中成员变量的初始化工作。动态构造函数可以重载，即相同构造函数名称拥有不同类型和数目的多个构造函数。带参数的构造函数和不带参数的构造函数没有本质区别，带参数的构造函数可以通过传入的变量控制或者直接初始化其中的成员变量，在构造函数中可以为成员变量初始化默认值。 静态构造函数不允许携带参数，即一个类中只允许有一个静态构造函数。它在第一次访问静态成员或者第一次实例化动态该类的对象之前调用。 override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。 重写（覆盖）的规则： 1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。 3、重写的方法的返回值必须和被重写的方法的返回一致； 4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类； 5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没s有对其进行重写。 6、静态方法不能被重写为非静态的方法（会编译出错）。 override就是子类将父类的方法重新实现了一遍。 new就是说这个方法就是子类自己的，跟父类没有任何继承关系关系，仅仅是重名
二、overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。
举个例子：
public class Shape
{
public static void main(String[] args){
Triangle tri = new Triangle();
System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
Shape shape = new Triangle();
System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
Rectangle Rec = new Rectangle();
Shape shape2 = Rec;
System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
}
public boolean isShape(){
return true;
}
public int getSides(){
return 0 ;
}
public int getSides(Triangle tri){ //重载
return 3 ;
}
public int getSides(Rectangle rec){ //重载
return 4 ;
}
}
class Triangle extends Shape
{
public int getSides() { //重写,实现多态
return 3;
}
}
class Rectangle extends Shape
{
public int getSides(int i) { //重载
return i;
}
}
注意Triangle类的方法是重写，而Rectangle类的方法是重载。对两者比较，可以发现多态对重载的优点：
如果用重载，则在父类里要对应每一个子类都重载一个取得边数的方法；
如果用多态，则父类只提供取得边数的接口，至于取得哪个形状的边数，怎样取得，在子类里各自实现(重写)。
