构造方法、package、静态属性、访问控制修饰符知识点

1.构造方法的重载：

                                  在一个类的定义中出现多个方法名相同，参数列表不同的多个同名方法

                                  共存的现象，作为方法的一个特例称为构造方法的重载。

                          

                          例如：

   

packageStudent;

 

classStudent1{

Stringname;

chargender;

public Student1(String n,char g){

name=n;

gender=g;

}

public Student1(String n){

name=n;

gender='m';

}

public Student1()

{

gender='m';

}

publicString output()

{

Strings=null;

s="姓名:"+name;

if(gender=='f')

s=s+"性别：女";

else

s=s+"性别；男";

returns;

}

}

 

publicclass Student {

publicstatic void main(String[] args) {

Student1 s1=new Student1("张三");

System.out.println(s1.output());

Student1 s2=new Student1("李四",'f');

System.out.println(s2.output());

}

}

2.变量的作用域：

                              （1）属性不管在何处声明，它的作用域都是整个类。

                              （2）局部变量必须先声明再使用，在使用前必须给定初始值，局部变量的       

                                         作用域范围是从定义的那一点到距离它最近的大反括号。

                              （3）当局部变量和属性重名时，在局部变量的作用域内局部变量屏蔽掉属                      

                                         性。

 

3.this关键字：

                            当局部变量和属性重名时，在局部变量的作用域内局部变量屏蔽掉属性。

                 例如：

                            

 

publicclass RectangleTest3 {

 

publicstatic void main(String[] args) {

Rectangleobj = new Rectangle(2, 3);

System.out.println("矩形的长是：" + obj.length + "举行的宽是："+ obj.width);

intresult = obj.area();

System.out.println("矩形的面积是：" + result);

}

 

}

classRectangle {

intlength = 1;

intwidth = 1;

 

publicint area() {

inttemp = length * width;

returntemp;

}

 

publicRectangle(int length, int width) {

this.length= length;

this.width= width;

}

 

publicRectangle() {

length= 5;

width= 5;

}

}

this关键字代表了当前类对象的一个引用，在属性前面加上this.，利用this.可以调用当前对象的方法和属性

this的用法：

（1）利用this调用当前对象的方法和属性。

（2）一个类的若干个属性可以相互调用，当一个构造方法需要调用另一个构造方法  

         时应使用this(实参列表)，同时这条语句应该是整个构造方法中的第一条语

         句。在利用this调用构造方法时根据实参的个数匹配调用的是哪个其他的构造

        方法。

（3）当方法需要返回当前正在讨论的对象时，可以采用return this的形式。

4.包(package)：

                             第一个包：

packagecom.fancy;

 

publicinterface Shapeable {

doublecalcArea();

doublecalcGirth();

}

   第二个包：

packagecom.fancy.aaa;

importcom.fancy.*;

 

classCircle implements Shapeable{

privatedouble radius;

publicCircle(double radius){

this.radius=radius;

}

publicdouble calcArea()

{

returnMath.PI*Math.pow(radius, 2);

}

publicdouble calcGirth()

{

return2*radius*Math.PI;

}

}

 

 

publicclass Ex4 {

publicstatic void main(String[] args) {

CircleaCircle=new Circle(1);

System.out.println("构建半径为1的圆");

System.out.printf("圆的面积：%.2f",aCircle.calcArea());

System.out.printf("\n圆周长为：%.2f",aCircle.calcGirth());

}

 

}

注意：在一个源程序文件中允许定义多个类，只有与文件名（不含扩展名）相同的类才能声明为public,因此，一个源文件只能有一个public。通常，包含main方法的主类声明为public。

导入包的语句：import 包名.类名；            import 包名.*；

 

如果在一个程序中涉及到两个包中的同类名，创建此类对象时需要明确指出该类所属的包：

包名.类名.对象名=new 包名.类名.对象名

5.访问控制修饰符：

                                    

publicclass AA {

privateint x;

publicdouble y;

protectedchar z;

String w;                                   //缺省属性

public AA(int a,double b,char c,String d){  //public修饰的构造方法

x=a;y=b;z=c;w=d;

}

private int getX(){                         //private修饰的访问器

returnx;

}

public double getY()                        //public修饰的访问器方法

{

returny;

}

protected char getZ()                       //protected修饰的访问器方法

{

returnz;

}

String getW()                               //缺省修饰符修饰的访问器方法

{

returnw;

}

}

 

publicclass ATest{

publicstatic void main(String args[]){

AAobj=new AA(1,1.11,'q',"hello");

obj.x=2;

obj.getX();

obj.y=2.22;

obj.getY();

obj.z='e';

obj.getZ();

obj.w="lala";

obj.getW();

 

}

}

 

 

注意：所谓的类内是指类定义的“{”和“}”之间，在类内可以直接使用被任何访问控制修饰符的属性和方法。

             所谓的允许访问和修改是指创建该类对象，并通过对象调用其属性。

             所谓的访问器方法就是指setter方法和getter方法，访问器方法的命名是set或get加上属性的名字，同时属性名字的第

                  一个字母要大写。

                                                set方法为属性赋值：publicvoid setXX（类型 形参）{

                                                                                        this.属性=形参；

                                                                                                                                                                              }

                                                                                       这里的形参的数据类型要和属性的数据类型一致。

                      get方法获取属性值：public 类型 getXX(){

                                                                 return 属性；

                                                                               }

                                        这里返回值类型要和属性的数据类型一致。

6.static修饰符：

                               示例代码：

package static修饰符;

 

classEmp {

publicString name;

privatedouble salary;

staticdouble minSalary;

 

publicString getName() {

returnname;

}

 

public  void setName(String n) {

name= n;

}

 

publicvoid setSalary(double s) {

if(s >= minSalary)

salary= s;

else

salary= minSalary;

}

 

publicstatic double getMinSalary() {

returnminSalary;

}

 

publicstatic void setMinSalary(double min) {

minSalary= min;

}

}

 

publicclass EmpTest {

 

publicstatic void main(String[] args) {

Emp.setMinSalary(600);

Empe1=new Emp();

    e1.name="huangbowen";

System.out.println(e1.name+"中读取出的员工最低工资：" + e1.getMinSalary());

Empe2 = new Emp();

System.out.println("e2中读取出的员工最低工资：" + e2.getMinSalary());

}

 

}

注意：(1) 这里的static称为静态修饰符。它所修饰的属性称为静态属性。

             (2)静态属性是和类相关的，而不是和具体对象相关的。

             (3)static也可以修饰方法，被static修饰的方法称为静态方法，是属于类的方法，而不是属于具体对象的方法，也称为类 

        方法。

             (4)静态方法可以用类名来调用，静态方法是随着类的创建而创建的。

             (5)静态方法不能操纵非静态属性。非静态方法可以操纵静态属性。

 

             调用静态方法和静态属性的两种调用方式：

                                                                               （1）类名.静态属性或静态方法

                                                                               （2）对象名.静态属性或静态方法

             静态初始化器：

                                         语法结构：static{

                                    静态属性名=初始值；

                                   }

            静态初始化器的作用是为整个类的属性即静态属性完成初始化工作。静态初始化器语句组中的语句当满足下列条件时被执行且只被执行一次：首次生成该类对象时（即用new创建对象时）或首次通过类名访问静态属性时。

 

            静态初始化器和构造方法的区别：

                                   （1）静态初始化器是对类进行初始化，构造方法是对类的对象进行初始化

                                   （2）静态初始化器在其所属的类导入内存时被调用，构造方法在用new创建对象时调用

                                   （3）静态初始化器是一组语句不是方法，构造方法是特殊的方法