------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
面向对象（2）
主要内容：《 构造方法、成员方法、static关键字、静态的成员方法、 static的注意事项 》
1 构造方法概述和格式
1.构造：实例化一个对象；new
2.方法：指的是某一个方法。
构造方法：跟构造相关的方法：
当我们"实例化"一个对象时，使用的语法：
Student stu = new Student();
后边的一对小括号就意味着调用了某个方法，这个方法就叫：构造方法；
我们之前都没有定义过构造方法，那时是系统自动为我们添加的；
自己定义构造方法：
语法要求：
1.构造方法的"方法名"必须和"类名"相同；
2.构造方法不能定义"返回值类型"，甚至是void；
构造方法的格式：
1.构造方法的方法名必须与类名相同；
2.不能定义返回值类型，甚至是void；
3.构造方法内部不能返回任何值。但可以写return;语句；表示：结束构造方法的执行
1 class Student{
2
3 //定义普通的方法：
4
5 void show(){
6
7 }
8
9 //定义构造方法
10
11 //如果我们程序员没有定义构造方法，编译器会自动为这个类添加一个构造方法：没有形参，里面什么都不做。
12
13 //当我们实例化这个类对象时，虚拟机就会自动调用这个构造方法。
14
15 /* Student(){
16
17 }
18
19 */
20
21 //我们可以自己定义一个构造方法，当再实例化这个类的对象时，将会调用这个构造方法。
22
23 Student(){
24
25 System.out.println("你构造了一个Student......");
26
27 }
28
29 }
30
31 class Demo {
32
33 public static void main(String[] args)
34
35 {
36
37 Student stu = new Student();
38
39 }
40
41 }
2 构造方法的作用
1.由于它是在实例化一个对象时，被调用。 一般它内部可以做一些"初始化"的工作，和其它一些"先期的准备工作"。
2.理解构造方法的作用：
给了我们一个机会，在实例化一个类对象之前，如果想做什么事情，就可以将代码写在"构造方法"里。这个方法每当实例化一个此类对象时，会被调用.
1 class Student{
2
3 String name;
4
5 int age;
6
7 char sex;
8
9 //定义一个构造方法，做一些初始化的操作。这个构造方法将会在每次实例化这个对象时被调用；
10 Student(){
11 name = "";
12 age = 20;
13 sex = ‘男‘;
14 System.out.println("构造了一个Student对象......");
15 }
16 }
17 class Demo {
18 public static void main(String[] args) {
19 Student stu = new Student();
20 System.out.println(stu.name);
21 System.out.println(stu.age);
22 System.out.println(stu.sex);
23 Student stu2 = new Student();
24 Student stu3 = new Student();
25 Student stu4 = new Student();
26 Student stu5 = new Student();
27 }
28 }
3 构造方法的重载及注意事项)—
构造方法的注意事项：
1.如果我们不定义构造方法，系统添加一个：无参，什么都不做；
2.如果我们定义了构造方法，那么系统将不再添加无参构造方法了；
3.构造方法也是可以"重载"：
构造方法重载的作用：
1.意味着这个类，可以使用多种方式构造；方便使用者来构造对象；
2.当我们实例化一个对象时，只能调用一个构造方法；其它构造方法将不会被调用；
3.构造方法重载，实际上为这个类提供了一定的"灵活度"；
1 class Student
2 {
3 private String name;
4 private int age;
5 private char sex;
6
7 //构造方法时可以进行重载的；
8 Student(){
9 System.out.println("无参的构造方法......");
10 }
11 Student(int n){
12 System.out.println("int的构造方法...... n = " + n);
13 }
14 Student(String name){
15 System.out.println("String的构造方法...... name = " + name);
16 }
17 //全参的构造方法
18 Student(String name,int age ,char sex){
19 this.name = name;
20 this.age = age;
21 this.sex = sex;
22 }
23 //提供一些get和set方法
24 void setName(String name){
25 this.name = name;
26 }
27 String getName(){
28 return this.name;
29 }
30 void setAge(int age){
31 this.age = age;
32 }
33 int getAge(){
34 return this.age;
35 }
36 void setSex(char sex){
37 this.sex = sex;
38 }
39 char getSex(){
40 return this.sex;
41 }
42 }
43 class Demo {
44 public static void main(String[] args) {
45 //调用无参的构造方法；
46 // Student stu = new Student();
47 //调用int参数的构造方法
48 // Student stu2 = new Student(20);//传递实参
49 //调用String参数的构造方法
50 // Student stu3 = new Student("刘德华");
51 //***********构造方法的作用*********
52 //之前我们可以通过set方法为成员属性赋值
53 Student stu = new Student();
54 stu.setName("刘德华");
55 stu.setAge(20);
56 stu.setSex(‘男‘);
57 //使用带参的构造方法
58 Student stu2 = new Student("张学友",20,‘男‘);
59 }
60 }
4 成员方法的分类及使用-一个标准的学生类
成员方法的分类：
成员方法：定义在类体中，跟我们之前讲过的"方法"是一样的。可以带参数，可以具有返回值；
成员方法的特点：必须要通过类的对象调用。必须先期实例化此类对象，因为只有实例化对象后，方法的空间才会被分配。
Student stu = new Student();
stu.show();
//不能直接调用show()
show();//错误。show()在Student类的内部，不能这样直接调用；
//不能通过类名调用:
Student.show();//错误：不能用"类名"调用；
分类：
1.无返回值，无形参；
2.有返回值，无形参；
3.无返回值，有形参；
4.有返回值，有形参；
1 class Student{
2 //私有的成员属性
3 private String name;
4 private int age;
5 private char sex;
6 //*********构造方法*********
7 //无参的
8 Student(){
9 }
10 Student(String name,int age,char sex){
11 this.name = name;
12 this.age = age;
13 this.sex = sex;
14 }
15 //一些get和set方法
16 void setName(String name){
17 this.name = name;
18 }
19 //有返回值，无形参
20 String getName(){
21 return this.name;
22 }
23 //无返回值，有形参
24 void setAge(int age){
25 this.age = age;
26 }
27 int getAge(){
28 return this.age;
29 }
30 void setSex(char sex){
31 this.sex = sex;
32 }
33 char getSex(){
34 return this.sex;
35 }
36 //无返回值，无形参
37 void show(){
38 System.out.println("大家好，我叫：" + this.name + ",性别：" + this.sex + ",今年：" + age + " 岁！");
39 }
40 //有返回值，有形参：
41 String toString(int n){
42 System.out.println("n = " + n);
43 return this.name;
44 }
45 }
46 class Demo {
47 public static void main(String[] args)
48 {
49 Student stu = new Student();
50 stu.show();//OK的；
51
52 show();//编译错误
53 Student.show();//编译错误
54 }
55 }
5 static关键字
static关键字：
1.static:静态的——全局的——整个应用程序范围内。
2.有些成员变量具有固定的值，一般不会更改。
如果它作为"普通成员变量"：意味着，每次实例化这个对象时，都会在堆中分配空间。所以，如果对象
多了后，就会造成"空间浪费"；
3.这时，我们可以将这种变量定义为:static
1 class Student
2 {
3 static String schoolName = "传智播客--北京校区";
4 String name;
5 int age;
6
7 Student(String name,int age){
8 this.name = name;
9 this.age = age;
10 }
11 }
12 class Demo
13 {
14 public static void main(String[] args)
15 {
16 Student stu = new Student("刘德华",20);
17 System.out.println("第一个学员打印：" + stu.schoolName);
18
19 stu.schoolName = "传智播客";//此值是共享的，只有一个存储空间。
20
21 Student stu2 = new Student("张学友",22);
22 System.out.println("第二个学员打印：" + stu2.schoolName);
23 }
24 }
6 static关键字的特点
静态属性的应用：
1.我们以后做项目时，总会有一些成员属性的值，在整个应用程序范围内是唯一的，
而且被整个应用程序共享。
例如：schoolName = "传智播客--北京校区";
2.我们可以将这种字段全部定义在某个类中，并声明为static的。
1 class Const
2 {
3 static String schoolName = "传智播客--北京校区";
4 //我们的整个应用程序需要经常的计算圆的面积，需要使用统一的π值
5 static double pi = 3.14159;
6 class Student{
7 String schoolName = Const.schoolName;
8 //例如此方法要计算圆的面积
9 void cal(){
10 Const.pi * 半径 的平方
11 }
12 }
13 class Teacher{
14 String schoolName = Const.schoolName;
15 }
16 class Demo {
17 public static void main(String[] args) {
18 System.out.println("Hello World!");
7 静态的成员方法以及特点
静态关键字的特点：
1.随着类的加载而加载；
2.优先于"对象"而存在；在没有任何此类的对象的情况下，就已经存在了；
3.被类的所有对象共享。也可以被其它类访问；
4.可以通过"类名"调用。也可以通过"对象名"调用;
1 class Const{
2 static String schoolName = "传智播客--北京校区";
3 static double PI = 3.14159;
4 }
5 class Demo {
6 public static void main(String[] args) {
7 // Const con = new Const();//第一new这个类的对象，也会先将静态成员分配空间
8
9 System.out.println(Const.schoolName);//第一次使用Const类时，会自动加载内部所有的"静态成员"，并分配空间
10 System.out.println(Const.schoolName);//直接在内存中取System.out.println(Const.schoolName);//直接在内存中取
11 Const con = new Const();
12 System.out.println("con打印：" + con.schoolName);
13 }
静态的成员方法(类方法)：
1.一个成员方法也可以被修饰为static(静态的)
2.一般一些"功能性"的方法：例如我们上午写的MyMath类中的加减乘除的一些方法
为了方便用户使用，我们可以将这些方法定位为：static。
3.用户使用时，可以不用实例化此类的实例，直接使用类名就可以调用了。
静态方法的应用：
1.我们以后做项目时，都会有一些"工具性"的方法：
例如：加、减、乘、除的方法；
对数组操作的一些方法：打印数组的内容，找数组中的最大值、最小值；
2.我们可以将这些"工具性"的方法定义在某个类
使用户可以通过"类名"就可以直接调用了，不需要实例化此类的对象，方便了用户使用；
1 class MyMath{
2
3 //此方法就可以不通过对象调用。可以通过类名直接调用。
4
5 static int add(int a ,int b){
6
7 return a + b;
8
9 }
10
11 }
12
13 class Demo {
14
15 public static void main(String[] args) {
16
17 //想使用add方法，必须先实例化一个MyMath对象；
18
19 // MyMath m = new MyMath();
20
21 // System.out.println(m.add(10,20));
22
23 //通过类名直接调用静态方法
24
25 System.out.println(MyMath.add(100,20));
8 static的注意事项
static关键字的小结和注意事项：
1.static可以修饰：
1).成员变量：存在静态存储区。被所有对象共享；
2).成员方法：存在静态存储区。被所有对象共享；
2.static关键字的特点：
1.随着类的加载而加载；
2.优先于对象而存在；
3.被所有类的对象共享；
4.可以通过"类名"调用，也可以通过"对象名"调用；
static关键字的注意事项：
1.在static的方法中，不能使用this关键字；(因为此时还没有对象空间产生)
2.静态方法，只能访问静态成员(静态成员变量和静态成员方法)
普通的成员方法：
普通的成员变量
普通的成员方法
静态的成员变量
静态的成员方法
静态的成员方法：
静态的成员变量
静态的成员方法
class Student
{
static String schoolName = "传智播客--北京校区";
}
class StudentTools
{
void show(){
Student stu = new Student();
}
}
class Demo
{
public static void main(String[] args)
{
int a = 10;
}
}
9 静态变量和成员变量的区别
静态变量和成员变量的区别：
1.所属不同
1).静态变量：属于某个类，又叫"类变量"。
2).成员变量：属于"对象"，每个对象都有独立的成员变量的空间。也叫"实例变量"；
2.内存中位置不同：
1).静态变量：在方法区的"静态存储区"中；
2).成员变量：在"堆"中；
3.在内存中出现时间不同：
1).静态变量：第一次使用这个类时，可能还不会产生对象。此时就会为静态变量分配空间；
2).成员变量：在实例化类对象时，才会分配空间；
4.调用不同：
1).静态变量：可以通过"类名"访问。也可以通过"对象"访问；
2).成员变量：必须要通过"对象"访问；
1 class Student{
2 static String schoolName = "传智播客--北京校区";
3 String name = "刘德华";
4 }
5 class Demo{
6 public static void main(String[] args)
7 {
8 System.out.println(Student.schoolName);//可以通过类名访问
9 //访问成员变量：name
10 Student stu = new Student();
11 System.out.println(stu.name);//必须通过对象名访问
12 System.out.println(stu.schoolName);//也可通过对象名访问。
13 }
14 }
10 main方法的格式详细解释
public static void main(String[] args)
public :表示"公有的"，任何类都可以访问的；
static :表示"静态的"，在不存在Demo的对象的情况下就可以直接访问；
void :返回值类型为"空"。
main :方法名，不是关键字。
形参：String[] args:字符串数组。用于执行这个main方法时，传入参数；
11 说明书的制作过程
此类用于封装一些对数组进行操作的一些方法
要对此类制作帮助文档：
1.类要被声明为public；
2.在源文件中添加"文档注释"；/**开头 * /结束。只有"文档注释"中的内容才会被编译到帮助文档中。
3.对"类"和"方法"，以及方法的参数和返回值进行详细说明；
4.在"命令提示符"下使用javadoc命令，生成帮助文档：
javadoc -d 目录名 -author -version ArrayTools.java
-d:使用目录；
目录名：会将生成的帮助文档存入到这个目录下
-author:识别@author标记；
-version:识别@version标记：
1 */
2 /**
3 一个对数组操作的类。包含了一些静态的方法。
4 @author 作者名
5 @version 1.0
6 */
7 public class ArrayTools
8 {
9 //由于是一个工具类，内部包含都是静态方法。所以也不需要构造了。
10 private ArrayTools(){
11 }
12 //查找数组的最大值
13 //参数：
14 //返回值：
15 /**
16 获取数组的最大值。
17 @param array 要查找的数组
18 @return max 数组中的最大值
19 */
20 public static int getMax(int[] array){
21 int max = array[0];
22 for(int i = 0;i < array.length ;i++){
23 max = array[i] > max ? array[i] : max;
24 }
25 return max;
26 }
27 //查找数组的最小值
28 /**
29 获取数组的最小值
30 @param array 要查找的数组
31 @return min 数组中的最小值
32 */
33 public static int getMin(int[] array){
34 int min = array[0];
35 for(int i = 0;i < array.length ;i++){
36 min = array[i] < min ? array[i] : min;
37 }
38 return min;
39 }
40 }