JAVA学习笔记Ⅰ——类和对象

文章目录

一、JAVA基础之对象
二、JAVA基础之成员变量
三、JAVA基础之构造方法
四、JAVA基础之static修饰
五、JAVA基础之初始化块

悟：从2016年深度学习大火以来，各种深度学习框架层出不穷，作为早期发布的TensorFlow也是在不断更新，从TensorFlow1.x时代进入TensoFlow2.x时代，从静态图机制转入动态图，TensorFlow拜托了其最为诟病的缺点。并且TensorFlow在全面性上碾压Pytorch，社区文档开发人员众多。TensorFlow Lite更能移动端的部署，例如Android与树莓派等。因此为了更好的将TensorFlow部署在移动端，Android的涉猎是少不了的。因此走了一波学习JAVA的路。

All Work for TensorFlow

一、JAVA基础之对象

创建对象	使用对象
类名对象名 = new 类名(); `Telphone phone = new Telphone();`	引用对象的属性：对象名.属性 `phone.screen = 5;//给screen属性赋值5` 引用对象的方法:对象名.方法名() `phone.sendMessage();//调用sendMessage()方法`

Telphone.java

package com.template4;

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有发短信的功能");
    }
}

InitialTelphone.java

package com.template4;

public class InitialTelphone {
    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();
    }
}

screen:0.0 cpu:0.0 mem:0.0 Telphone有发短信的功能
screen:5.0 cpu:1.4 mem:2.0 Telphone有发短信的功能

二、JAVA基础之成员变量

成员变量	局部变量
在类中定义，用来描述对象有什么。成员变量可以被本类的所有方法使用，可以被一些其它和我们有关系的类中的方法使用。成员变量的作用域在整个类内部都是可见的。JAVA会给成员变量一个初始值。	在类的方法中定义，在方法中临时保存数据。局部变量只能在当前的方法中使用。局部变量的作用域仅限于定义它的方法。JAVA不会给局部变量赋予初始值。同一方法中不允许有同名的局部变量。在不同方法中可以有同名局部变量。

成员变量与局部变量

注意：两类变量同名时，局部变量具有更高的优先级（就近原则）

第一则代码段如下
Telphone.java

package com.template4;

public class Telphone {
    //属性
    float screen;
    float cpu;
    float mem;
    int var;
    
    void call(){
        System.out.println("var:"+var);
        System.out.println("Telphone有打电话的功能！");
    }
    void sendMessage(){
        System.out.println("var:"+var);
        System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem+" Telphone有发短信的功能");
    }
}

InitialTelphone.java

package com.template4;

public class InitialTelphone {
    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();
        phone.call();
    }
}

var:0
screen:0.0 cpu:0.0 mem:0.0 Telphone有发短信的功能
var:0
screen:5.0 cpu:1.4 mem:2.0 Telphone有发短信的功能
var:0
Telphone有打电话的功能！

第一则代码段表示对于未初始化的成员变量，系统会默认初始化成员变量为0

第二则代码段如下：
Telphone.java

package com.template4;

public class Telphone {
    //属性
    float screen;
    float cpu;
    float mem;
    int var;
    
    void call(){
        int localVar = 0;
        System.out.println("var:"+var);
        System.out.println("Telphone有打电话的功能！");
    }
    void sendMessage(){
        System.out.println("localVar"+localVar);
        System.out.println("var:"+var);
        System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem+" Telphone有发短信的功能");
    }
}

第二则代码段表明对于未初始化的成员变量，系统不会默认初始化为任何值，成员变量必须初始化，否则会报错

第三则代码段如下
Telphone.java

package com.template4;

public class Telphone {
    //属性
    float screen;
    float cpu;
    float mem;
    int var;
    
    void call(){
        int localVar = 10;
        System.out.println("localVar:"+localVar);
        System.out.println("var:"+var);
        System.out.println("Telphone有打电话的功能！");
    }
    void sendMessage(){
        int localVar = 20;
        System.out.println("localVar:"+localVar);
        System.out.println("var:"+var);
        System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem+" Telphone有发短信的功能");
    }
}

localVar:20
var:0
screen:0.0 cpu:0.0 mem:0.0 Telphone有发短信的功能
localVar:20
var:0
screen:5.0 cpu:1.4 mem:2.0 Telphone有发短信的功能
localVar:10
var:0
Telphone有打电话的功能！

Telphone.java

package com.template4;

public class Telphone {
    //属性
    float screen;
    float cpu;
    float mem;
    int var;
    int localVar = 100;
    
    void call(){
        int localVar = 10;
        System.out.println("localVar:"+localVar);
        System.out.println("var:"+var);
        System.out.println("Telphone有打电话的功能！");
    }
    void sendMessage(){
        int localVar = 20;
        System.out.println("localVar:"+localVar);
        System.out.println("var:"+var);
        System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem+" Telphone有发短信的功能");
    }
}

localVar:20
var:0
screen:0.0 cpu:0.0 mem:0.0 Telphone有发短信的功能
localVar:20
var:0
screen:5.0 cpu:1.4 mem:2.0 Telphone有发短信的功能
localVar:10
var:0
Telphone有打电话的功能！

第三则代码段表明在成员变量名具有“就近原则”，在成员变量与局部变量同名时，在局部变量的方法中会优先采用局部变量

三、JAVA基础之构造方法

构造方法	构造方法的重载
当没有指定构造方法时，系统会自动的添加无参构造方法，当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法	方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法

利用有参构造方法，可以将传入的变量进行修正

Telphone.java

package com.template4;

public class Telphone {
    //属性
    float screen;
    float cpu;
    float mem;

    public Telphone(){
        System.out.println("无参的构造方法");
    }
    public Telphone(float screen, float cpu, float mem){
        if (screen < 3.5f){
            System.out.println("您输入的参数有问题");
            screen = 3.5f;
        }
        else{
            screen = screen;
        }
        mem = mem;
        cpu = cpu;
        System.out.println("有参构造方法");
        System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem+" Telphone有发短信的功能");
    }
}

InitialTelphone.java

package com.template4;

public class InitialTelphone {
    public static void main(String[] args){
        //通过无参的构造方法可以创建对象
        Telphone phone_1 = new Telphone();
        //通过有参的构造方法可以创建对象 并给对象中的实例变量赋初值
        Telphone phone_2 = new Telphone(1.5f, 1.4f,2.0f);
    }
}

无参的构造方法
您输入的参数有问题
有参构造方法
screen:3.5 cpu:1.4 mem:2.0 Telphone有发短信的功能

四、JAVA基础之static修饰

我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~，这样可以有效区分静态成员变量与非静态成员变量

HelloWorld.java

package com.template5;

public class HelloWorld {
    static int static_hello = 1;
    int hello = 1;

    public void staticHelloChange() {
        System.out.println("static_hello:"+(++static_hello));
    }

    public void helloChange() {
        System.out.println("hello:"+(++hello));
    }
}

InitialHelloWorld.java

package com.template5;

public class InitialHelloWorld {
    public static void main(String[] args) {
        //使用对象名进行访问
        HelloWorld hello_1 = new HelloWorld();
        hello_1.staticHelloChange();
        hello_1.helloChange();
        HelloWorld hello_2 = new HelloWorld();
        hello_2.staticHelloChange();
        hello_2.helloChange();
        HelloWorld hello_3 = new HelloWorld();
        hello_3.staticHelloChange();
        hello_3.helloChange();
        HelloWorld hello_4 = new HelloWorld();
        hello_4.staticHelloChange();
        hello_4.helloChange();
        HelloWorld hello_5 = new HelloWorld();
        hello_5.staticHelloChange();
        hello_5.helloChange();
        //使用类名访问
        System.out.println(HelloWorld.static_hello);
        //使用对象名来修改值
        hello_1.static_hello = 100;
        System.out.println(HelloWorld.static_hello);
        //使用类名来修改值
        HelloWorld.static_hello = 500;
        System.out.println(HelloWorld.static_hello);
    }
}

static_hello:2
hello:2
static_hello:3
hello:2
static_hello:4
hello:2
static_hello:5
hello:2
static_hello:6
hello:2
6
100
500

对于static修饰的变量static_hello ，属于所有对象共享，因此没创建一个对象，值都会被更新。但对于未采用static修饰的变量hello，则对象之间的值相互独立。

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。同样推荐使用类名对静态方法进行调用。

• 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
• 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
• 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

HelloWorld.java

package com.template5;

public class HelloWorld {
    static int static_hello = 1;
    int hello = 1;

    //静态方法可以直接调用同类静态成员
    public static void staticHelloChange() {
        System.out.println("static_hello:"+(++static_hello));
    }

    //静态方法不能直接调用非静态成员
    public static void helloChange() {
        System.out.println("hello can not be used for static method");
    }

    //静态方法中创建类的对象来调用非静态变量
    public static void helloChangeS() {
        HelloWorld hello = new HelloWorld();
        System.out.println(hello.hello);
    }
}

InitialHelloWorld.java

package com.template5;

public class InitialHelloWorld {
    public static void main(String[] args) {
        //通过类名调用
        System.out.println(HelloWorld.static_hello); //1
        HelloWorld.helloChange(); //hello can not be used for static method
        HelloWorld.helloChangeS(); //1
        //通过对象名调用
        HelloWorld hello = new HelloWorld();
        hello.helloChange(); //hello can not be used for static method
        hello.helloChangeS(); //1
        System.out.println(hello.static_hello); //1
        System.out.println(hello.hello); //1
    }
}

1
hello can not be used for static method
1
hello can not be used for static method
1
1
1

五、JAVA基础之初始化块

Java 中可以通过初始化块进行数据赋值。在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

package com.template6;

public class HelloWorld {
    int num1; //声明変量num1
    int num2; //声明変量num2
    static int num3; //声明静态変量num3
    public HelloWorld() {// 构造方法
        num1 = 91;
        System.out.println("通过构造方法为变量num1賦値");
    }

    {//初始化块
        num2 = 74;
        System.out.println("通过构造方法为变量num2賦値");
    }
    static {//静态初始化块
        num3= 83;
        System.out.println("通过构造方法为变量num3賦値");
    }
    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();//创建类的对象hello
        System.out.println("num1:" + hello. num1);
        System.out.println("num2:" + hello. num2);
        System.out.println("num3:" + num3);
        HelloWorld he11o2 = new HelloWorld();// 再创建类的对象hello2
    }
}

通过构造方法为变量num3賦値
通过构造方法为变量num2賦値
通过构造方法为变量num1賦値
num1:91
num2:74
num3:83
通过构造方法为变量num2賦値
通过构造方法为变量num1賦値

通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。