java类和对象、构造方法、静态变量、静态方法、静态初始化块

类

类是模子，确定对象将会拥有的特征（属性）和行为（方法）

类的特点

类是对象的类型

具有相同属性和方法的一组对象的集合

属性——对象具有的各种特征，每个对象的每个属性都拥有特定值

方法——对象执行的操作

类是抽象的概念，仅仅是模板，比如说：“手机”对象是一个看得到、摸得着的具体实体

如何定义java中的类

1、类的重要性：所有java程序都以类（class）为组织单元

2、什么是类？类是模子，确定对象将会拥有的特征（属性）和行为（方法）

3、类的组成：属性和方法

4、定义一个类的步骤

a、定义类名

b、编写类的属性

c、编写类的方法

Java对象

1、创建对象

类名 对象名=new 类名();

Telphone phone=new Telphone();

2、使用对象

引用对象的属性：对象名.属性

Phone.screen=5;//给screen熟悉赋值为5

引用对象的方法：对象名.方法名()

Phone.sendMessage();//调用sendMessage()方法

public class TelPhone {
    //属性（成员变量）  有什么
    float screen;
    float cpu;
    float mem;
    //方法   干什么
    void call(){
        System.out.println("telphone有打电话的功能");
    }
    void sendMessage(){
        System.out.println("screen:"+screen+"cpu:"+cpu+"mem:"+mem+"telphone有发短信的功能");
    }
}
public class InitailTelPhone {
    public static void main(String[] args){
        //创建类的对象
        TelPhone phone=new TelPhone();
        //调用类的方法
        phone.sendMessage();
        //给实例变量赋值
        phone.screen=5.0f;
        phone.cpu=1.4f;
        phone.mem=2.0f;
        //再次调用类的方法
        phone.sendMessage();
    }
}

java中的成员变量和局部变量

1、成员变量

  在类中定义，用来描述对象将要有什么

本类的方法可以使用，或其它有关系的类的方法也可以使用

2、局部变量

  在类的方法中定义，在方法中临时保存数据

只有在当前方法中才能使用

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

1、作用域不同

局部变量的作用域仅限于定义它的方法内部使用

成员变量的作用域在整个类的内部都是可以使用的

2、初始值不同

Java会给成员变量一个初始值，初始值为0

局部变量没有初始值

3、在同一个方法中，不允许有同名的局部变量

4、在不同的方法中，可以有同名的局部变量

5、两类变量同名时，局部变量有更高的优先级

java中的构造方法

1、使用new+构造方法，可以创建一个新的对象

Tips:在创建对象时，new+的其实是构造方法

2、构造方法是定义在java类中的一个用来初始化对象的方法

3、构造方法与类同名且没有返回值

无参的构造方法

main：

　　Telphone phone=new Telphone();//构造方法名称

class Telphone:

　　public Telphone(){

　　System.out.println("无参的构造方法执行了！");

}

带参构造方法的使用

main：

　　Telphone phone=new Telphone(4.0f,2.0f,2.0f);  // 构造方法名称，括号里为构造方法的参数

class Telphone:

　　public Telphone(float newScreen,float newCpu,float newMen){

　　screen=newScreen;

　　cpu=newCpu;

　　mem=newMen;

}

public class InitailTelPhone {
    public static void main(String[] args){
        //通过无参的构造方法创建类的对象
        TelPhone phone=new TelPhone();
        //通过有参的构造方法创建类的对象，并给对象中的实例变量赋初值
        TelPhone phone2=new TelPhone(5.0f,2.0f,3.0f);
    }
}
public class TelPhone {
    //定义成员变量
    float screen;
    float cpu;
    float mem;
    public TelPhone(){
        System.out.println("无参的构造方法执行了");
    }
    //带参数的构造方法
    //括号里的参数和成员变量是有区别的
    public TelPhone(float newScreen,float newCpu,float newMen){
        //为成员变量赋初值
        screen=newScreen;
        cpu=newCpu;
        mem=newMen;
        System.out.println("有参的构造方法执行了");
    }
}

当没有指定构造方法时，系统会自动添加无参的构造方法

当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法

构造方法的重载：方法名相同，但参数不同的多个方法，调用是会自动根据不同的参数选择对应的方法

构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值

        //带参数的构造方法
    //括号里的参数和成员变量是有区别的
    public TelPhone(float newScreen,float newCpu,float newMen){
        //为成员变量赋初值，并保证赋一个合理的值
        if(newScreen<3.5f){
            System.out.println("您输入的参数有问题，自动赋值3.5");
            screen=3.5f;
        }else{
            screen=newScreen;
        }
        cpu=newCpu;
        mem=newMen;
        System.out.println("有参的构造方法执行了");
    }    

Static使用之静态变量

被static修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。

使用static可以修饰 变量、方法、代码块。

public class HelloWorld{
    //定义静态变量
    static String name="liuYun";
    int a=10;
    public static void main(String[] args){
        System.out.println(HelloWorld.name);//可以使用类名直接访问
        System.out.println(name);//这样居然可以直接访问
        HelloWorld hello=new HelloWorld();
        System.out.println(hello.a);//非静态变量用对象名访问
    }
}

Static使用之静态方法

1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果希望在静态方法中调用非静态变量，可以通过创建类的对象来访问非静态变量

2、在普通成员方法中，则可以直接调用同类的非静态变量和静态变量

3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法

public class HelloWorld{
    //定义静态变量
    static int score1=86;
    static int score2=92;
    //定义静态方法sum
    public static int sum(){
        int sum;
        sum=score1+score2;
        return sum;
    }
    public static void main(String[] args){
        int sum=HelloWorld.sum();//调用静态方法
        System.out.println("总分："+sum);
    }
}

Static使用之静态初始化块

Java中可以通过初始化块进行数据赋值

public class HelloWorld{
    String name;//定义一个成员变量
    //通过初始化块为成员变量赋值
    {
        name="liuYun";
    }
}

如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：

静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，

不能初始化普通的成员变量。

public class HelloWorld{
    String name;
    String sex;
    static int age;
    //构造方法
    public HelloWorld(){
        System.out.println("通过构造方法初始化name");
        name="liuYun";
    }
    //初始化块
    {
        System.out.println("通过初始化块初始化sex");
        sex="男";
    }
    //静态初始化块
    static{
        System.out.println("通过静态初始化块初始化age");
        age=29;
    }
    public void show(){
        System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age);
    }
    public static void main(String[] args){
        HelloWorld hello=new HelloWorld();
        hello.show();
    }
}