【骚全带你学Java---十、面向对象，构造函数，static关键字】

面向对象

概述

• 对于面向过程思想，强调的是过程（动作） C语言

• 对于面向对象，强调的是对象（实体） C++ Java C#，Objective-c,python，Swift等

特点

• 面向对象就是一种常见的思想，符合人们的思考习惯。

• 面向对象的出现，将复杂的问题简单化。

• 面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

类与对象

java语言对现实生活中的事物进行描述，通过类的形式来体现。
对于事物的描述通常只关注两方面：

• 一个是属性（变量）

• 一个是行为（方法）
  只要明确该事物的属性和行为并在类中定义即可。

类： 事物的描述

对象：该类事物的实例。java中通过new来创建。

定义类其实就是在定义类中的成员。

成员：成员变量<–>属性 成员方法<–>行为。

成员变量和局部变量的区别：

• 1.成员变量定义在类中，整个类中都可以访问。局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

• 2.成员变量存在于堆内存中的对象中。局部变量存在于栈内存的方法中。

• 3.成员变量随着对象的创建而存在，随着对象的消失而消失。局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

• 4.成员变量都有默认初始化值。局部变量没有默认初始化值。

构造函数

定义：创建构造对象时调用的函数。
作用：可以给对象经行初始化。（创建对象都必须要通过构造函数初始化）

package com.duwenquan.learnjava;

public class LearnJavaDemo {
    public static void main(String[] args) {
        LearnJava learn1=new LearnJava();            //输出Hello World。new对象一建立，就会调用对应的构造函数LearnJava()，并执行其中的println语句。
    }
}
class LearnJava{        
    LearnJava(){        //定义构造函数，输出Hello World
        System.out.println("Hellow World");
    }
}

特点

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2.每个类可以有一个以上的构造器
3.构造器可以有0个、1个或1个以上的参数
4.构造器没有返回值
5.构造器总是伴随着new操作一起调用。
6.使用super调用父类构造器的语句必须是子类构造器的第一条语句。

构造函数与普通函数的区别

1，格式不同：
构造函数不存在返回类型，函数名与所在类的类名一致；
普通函数有返回类型，函数名可以根据需求进行命名。

2，调用时期不同：
构造函数在类的对象创建时就运行；
普通函数在对象调用时才会执行。

3，执行次数不同：
一个对象创建后，其构造函数只执行一次，就是创建时执行；
一个对象创建后，其普通函数可以执行多次，取决于对象的调用次数。

构造函数的示例

public class Stu1 {

    public Stu1()
    {
        System.out.println("调用了Stu1类的无参构造函数。");
    }

    public Stu1(String name)
    {
        System.out.println("调用了Stu1类的有参构造函数，参数内容："+name);
    }
}


public class Stu2 extends Stu1{

    public Stu2(){

        System.out.println("调用了Stu2类的无参构造函数。");
    }

    public Stu2(String name){

        super(name);
        System.out.println("调用了Stu2类的有参构造函数, 参数内容: "+name);
    }


}


import java.util.*;
public class TestConstr {

    public static void main(String []args)
    {
        Stu2 stu=new Stu2();
        Stu2 stu2=new Stu2("zhangsan");
    }

}
//输出结果
//调用了Stu1类的无参构造函数。
//调用了Stu2类的无参构造函数。
//调用了Stu1类的有参构造函数，参数内容：zhangsan
//调用了Stu2类的有参构造函数，参数内容：zhangsan

注意

1.一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
2.如果在类中定义了指定的构造函数那么类中的默认构造函数就没有了。
3.构造函数可以有多个，用于对不同的对象进行针对性的初始化。
4.多个构造函数在类中是以重载的形式来体现的。

Java中的static关键字

static关键字的特点

• 1.static是一个修饰符，用于修饰成员。（成员变量，成员函数）static修饰的成员变量 称之为静态变量或类变量。
• 2.static修饰的成员被所有的对象共享。
• 3.static优先于对象存在，因为static的成员随着类的加载就已经存在。
• 4.static修饰的成员多了一种调用方式，可以直接被类名所调用，（类名.静态成员）。
• 5.static修饰的数据是共享数据，对象中的存储的是特有的数据。

1     private static int age;//用static修饰的成员变量静态变量或者叫做类变量
2     private String name;   //成员变量
3     public static void display(){//静态函数 可直接用类来调用
4         System.out.println("displayStatic");
5     }
6     public void displayTest(){//成员函数 需要创建对象才可以调用
7         System.out.println("displayTest");
8     }

成员变量和静态变量的区别

1.生命周期的不同：
　　　　成员变量随着对象的创建而存在随着对象的回收而释放。
　　　　静态变量随着类的加载而存在随着类的消失而消失。
2.调用方式不同：
　　　　成员变量只能被对象调用。
　　　　静态变量可以被对象调用，也可以用类名调用。（推荐用类名调用）
3.别名不同：
　　　　成员变量也称为实例变量。
　　　　静态变量称为类变量。
4.数据存储位置不同：
　　　　成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
　　　　静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

 1 public class Test {
 2     private static int age;//用static修饰的成员变量静态变量或者叫做类变量
 3     private String name;   //成员变量
 4     public static void display(){//静态函数 可直接用类来调用
 5         System.out.println("displayStatic");
 6     }
 7     public void displayTest(){//成员函数 需要创建对象才可以调用
 8         System.out.println("displayTest");
 9     }
10     
11     public static void main(String[] args) {
12         Test.age = 1;//静态变量可以直接用类名调用。随着类加载而存在类的消失而消失
13         Test d = new Test();
14         d.age = 28;//静态变量也可以通过对象来调用（推荐用类名来调用）
15         d.name="杜文全";//成员变量只能通过对象来调用。随着对象创建而存在随着对象回收而释放。
16         Test.display();//静态方法也可以直接用类名调用。
17         d.display();    //静态方法也可以通过对象来调用。
18         d.displayTest();//非静态方法只能通过对象来调用。
19     }
20 }

静态使用时需要注意的事项：

1.静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）
2.静态方法中不可以使用this或者super关键字。
3.主函数是静态的。

 1 public class Test {
 2     private static int age;//用static修饰的成员变量静态变量或者叫做类变量
 3     private String name;   //成员变量也叫做实例变量
 4     
 5     public static void display(){//静态函数
 6         Test d = new Test();//因为静态先于对象加载如果需要访问必须要创建对象才能访问
 7         d.name = "杜文全";//静态方法不能直接访问非静态的成员变量
 8         d.displayTest();//静态方法不能直接访问非静态的成员函数
 9         System.out.println(d.name);
10     }
11     public void displayTest(){//成员函数
12         age = 28;//可以直接访问静态变量
13         display();//也可以直接访问静态函数
14         System.out.println(age);
15     }
16 }    

static修饰的使用场景

• 1.静态变量：

当分析对象中所具备的成员变量的值都是相同的。这时这个成员就可以被静态修饰。
只要是数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，是静态的。

• 2.静态函数。

函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中特有的数据。
简单来说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用，而仅创建对象是没有意义的。

• 3.单例设计模式：

static一个很重要的用途就是实现单例设计模式。单利模式的特点是该类只能有一个实例，为了实现这一功能，必须隐藏类的构造函数，即把构造函数声明为private，并提供一个创建对象的方法，由于构造对象被声明为private，外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为static，程序实例如下：

class Singleton{
    private static Singleton instance=null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

• 4.静态代码块
  　 　随着类的调用或创建实例而执行，而且只执行一次。
  作用：　用于给类进行初始化。

 1 public class Test {//如果想让此类成为一个静态类而类中需要用到一些参数需要初始化就需要静态代码块
 2     private static  int age;
 3     private static String name;
 4     //省略get、set方法
 5     static{//当类第一次调用或创建实例时给属性初始化且只执行一次。
 6         age = 28;
 7         name = "杜文全";       
 8     }
 9     public static void displayNoen(){//调用此方法age为28name为杜文全（默认值）
10         System.out.println("年龄："+age+"姓名："+name);
11     }
12     public static void display(int age,String name){//调用此方法会覆盖掉默认值
13         Test.age = age;
14         Test.name = name;
15         System.out.println("年龄："+Test.age+"姓名："+Test.name);
16     }
17     public static void main(String[] args) {
18         Test.displayNoen();//结果为：年龄：28姓名：杜文全
19         Test.display(24, "张传龙");//结果为：年龄：24姓名：张传龙
20     }
21 }

• 5.构造代码块（主函数）

作用：给所用对象进行初始化
主函数特殊之处：

• 1.格式固定。
• 2.被jvm所识别和调用。
  public static void main(String[] args){

}
public:因为权限必须是最大的。
static:jvm在调用时是不需要对象的，直接用主函数所属的类名调用即可。
void:主函数没有具体的返回值 。
main:函数名，不是关键字，只是一个jvm识别的固定名字。
String[] args:这是主函数的参数列表，是一个数组类型的参数，而且袁术都是字符串类型。