------- android培训、java培训、期待与您交流！ ----------
黑马程序员------面向对象（二）
1.1 构造函数
1.1.1特点： 1、函数名与类名相同 2、不用定义返回值类型 3、不可以写return语句 4、对象一建立就会调用与之对应的构造函数 作用：给对象进行初始化。1.1.2构造函数的小细节：1、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
2、当在类中自定义了构造函数后，默认的构造函数就没有了。
3、多个构造函数是以重载的形式存在的。
1.1.3构造函数和一般函数的区别：
1、在写法上有不同，在运行上也有不同。
2、构造函数：在对象一建立就运行。给对象初始化。
3、一般方法：对象调用才执行，给是对象添加对象具备的功能。
4、构造函数：对象创建时，会调用并且只调用一次。
5、一般函数：对象创建后，可以被调用多次。
什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
示例1：
1 class Person 2 { 3 private String name ; 4 private int age ; 5 { 6 //System.out.println("person run code" );//构造代码块 7 cry(); 8 } 9 Person()//定义一个空参数的Person类构造函数 10 { 11 System.out.println("person run code" ); 12 } 13 public void cry() 14 { 15 System.out.println("........cry......"); 16 } 17 } 18 19 class PersonDemo 20 { 21 public static void main(String[] args) 22 { 23 Person p = new Person();//创建对象并初始化 24 p.cry(); 25 } 26 }
1.1.4构造代码块。
{ 语句 }作用：给对象进行初始化。 对象一建立就运行，而且优先于构造函数执行。 和构造函数的区别： 构造代码块是给所有对象进行统一初始化， 而构造函数是给对应的对象初始化.
构造代码快中定义的是不同对象共性的初始化内容。
2.1 this关键字：隐式参数，用于区分成员和局部变量的同名情况
this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
在普通方法中，this总是指向调用该方法的对象。
在构造方法中，this总是指向正要初始化的对象。
this不能用于static方法中。还可以用来调用其他的构造方法。
this关键字的应用。
在定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this表示这个对象，但凡本类功能内部使用到了本类对象，都用this表示。
this关键字在构造函数间调用：
this（）;用于构造函数间的调用。
通过this调用构造方法，必须位于第一句。
示例2： 1 class Person 2 { 3 private String name ; 4 private int age ; 5 6 Person(String name) 7 { 8 this.name = name;//通过this区分成员变量和局部变量 9 } 10 11 Person(String name, int age) 12 { 13 //this用于在构造函数中调用其他构造函数 14 this(name); 15 this.age = age; 16 } 17 18 public void tell() 19 { 20 System.out.println(name + ":" + age ); 21 } 22 /* 23 需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。 24 */ 25 public boolean compare(Person p) 26 { 27 return this.age==p.age; 28 } 29 } 30 31 class staticDemo 32 { 33 public static void main(String[] args) 34 { 35 Person p1 = new Person("不三" ); 36 p1.tell(); 37 Person p2 = new Person("不四" ,10); 38 p2.tell(); 39 } 40 }
注意：通过this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。
3.1 static关键字
3.1.1 static特点：
1、随着类的加载而加载。
也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2、优先于的对象存在明确一点：静态是先存在。对象是后存在的。
3、被所有对象所共享4、可以直接被类名所调用。
3.1.2 实例变量和类变量的区别：1，存放位置。 类变量随着类的加载而存在于方法区中。 实例变量随着对象的建立而存在于堆内存中。2，生命周期： 类变量生命周期最长，随着类的消失而消失。 实例变量生命周期随着对象的消失而消失。
示例3：
1 class Person 2 { 3 String name;//成员变量，实例变量。 4 static String country = "CN";//静态的成员变量，类变量,卑static修饰的属性为所有对象所共享 5 public static void show() 6 { 7 System.out.println("::::"); 8 this.haha(); 9 } 10 public void haha() 11 { 12 } 13 } 14 15 class StaticDemo 16 { 17 public static void main(String[] args) 18 { 19 Person p = new Person(); 20 //p.name = "zhangsan"; 21 //p.show(); 22 23 //System.out.println(p.country); 24 25 //System.out.println(Person.country);//用类名直接调用 26 27 Person.show(); 28 } 29 }
3.1.3 静态使用注意事项：1、静态方法只能访问静态成员。 非静态方法既可以访问静态也可以访问非静态。2、静态方法中不可以定义this，super关键字。 因为静态优先于对象存在。所以静态方法中不可以出现this。3、主函数是静态的。
4、静态方法只能访问静态成员，如果访问非静态成员，就会报错！（参考示例4） 原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问
示例4：
1 class Person 2 { 3 String name; 4 static String country = "CN"; 5 //静态方法 6 public static void show() 7 { 8 System.out.println(country + ":" + name); 9 } 10 }
3.1.4 静态有利有弊利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用。弊端：生命周期过长。 访问出现局限性。(静态虽好，只能访问静态。)
3.1.5主函数：是静态的，是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被jvm识别。（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的：jvm识别。
jvm在调用主函数时，传入的是new String[0];
示例6：
1 class MainDemo 2 { 3 public static void main(String[] args)//new String[] 4 { 5 String[] arr = {"hah","hhe","heihei","xixi","hiahia"}; 6 7 MainTest.main(arr); 8 } 9 }
3.1.6 静态什么时候用？
1. 静态变量(类变量)
当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
2. 静态函数
当功能内部没有访问到肺静态数据(对象的特有数据)，那么该功能可以定义成静态的。
示例7：
1 class Person 2 { 3 String name; 4 static String country = "cn"; 5 public static void show() 6 { 7 System.out.println(contry+"haha"); 8 } 9 10 } 11 12 13 class 14 { 15 public static void main(String[] args) 16 { 17 Person p = new Person(); 18 p.show(); 19 //Person .show(); 20 } 21 22 }
3.1.7 静态代码块
格式：static{ 静态代码块中的执行语句。}
特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。
示例8：
1 class StaticCode 2 { 3 int num = 9; 4 StaticCode()//构造代码块，可以给所有对象进行初始化的 5 { 6 System.out.println("b"); 7 } 8 9 static 10 { 11 System.out.println("a"); 12 } 13 { 14 System.out.println("c"+this.num); 15 } 16 17 StaticCode(int x) 18 { 19 System.out.println("d"); 20 } 21 public static void show() 22 { 23 System.out.println("show run"); 24 } 25 } 26 27 class StaticCodeDemo 28 { 29 static 30 { 31 //System.out.println("b"); 32 } 33 public static void main(String[] args) 34 { 35 new StaticCode(4);//a c d 36 //new StaticCode(); 37 //new StaticCode(); 38 //System.out.println("over"); 39 //StaticCode.show(); 40 //StaticCode s = null; 41 //s = new StaticCode(); 42 43 //StaticCode.show(); 44 45 46 } 47 static 48 { 49 ///System.out.println("c"); 50 } 51 }
转载于:https://www.cnblogs.com/jiandonn/p/4572380.html
