初识Java之基础语法篇(上)

时间:2020-8-31 作者:admin


Java的基础语法就不像Python那样言简意赅,清楚明了。虽然Java是需要我们反复的去理解,才可以真正的认识到如何做到和Python的一样效果,但是只要你学进去了,最后发现基础依然是那些,只是站的高度不同罢了。

就好比如说Python的打印就只需要print()函数即可,非常的简单,而Java是需要很多代码的。

给大家简单的看一个输入和输出的Java程序

引入

import java.util.Scanner;
public class study1 {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入一个数");
        int a=scanner.nextInt();
        System.out.printf("%d的平方是%d\n",a,a*a);

简单的描述一下就是,Java需要对类的属性了解到位,什么时候要用私有的,共同的,或者有时候需要定义变量,常量这些,都是和我们的Python的语法大相径庭的,所以在学习Java的过程中一定要掌握好基础的节奏,慢慢的去学。


public class HelloWorld {
    /* 第一个Java程序
     * 它将打印字符串 Hello World
     */
    public static void main(String[] args) {
        System.out.println("Hello World"); // 打印 Hello World
    }
}

public static void main(String[]args){
	System.out.println()}

一般主类都是有的,这个可能使我们自己要写的,熟记于心,而且每个后面的都需要加入分号!!!!!!!!!!!!


Java包
Java包是基础的一个概念,我们需要导入这个包的时候,依然用import+文件(包)这个的话需要去官网去了解一下,这里我就不做过多的叙述了。
类的成员变量和局部变量
成员变量可以在类的各个地方调用,局部变量只能在声明的方法内使用

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized

对于访问控制修饰符我们从单词的意思就可以直接了解这个,public就是公开的,对其他文件包括类都是开发的。private是私有属性,只能在自己的类文件使用。

语法点拨

大小写敏感:Java 是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的。
类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记 Java 是大小写敏感的),文件名的后缀为 .java。(如果文件名和类名不相同则会导致编译错误)。
主方法入口:所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。关于 Java 标识符,有以下几点需要注意:

所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开始
首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例:age、$salary、_value、__1_value
非法标识符举例:123abc、-salary

初识Java之基础语法篇(上)
基本数据类型
规律性的:
byte:
占用内存8位,max=2^7 -1,min=-2^7,占用int类型的四分之一
short:
占用内存16位,max=2^15 -1,min=-2^15,占用int类型的二分之一
规律说明后面依次的int,long类型都是这样的32,64,对应的运算都是减一。

我们有的时候在进行定义数据的时候,如果超过了就会导致储存的溢出,所以为了程序的健壮我们需要了解这些东西。

上机操作

public class study1{
//    全局常量,可以在本类的任何的地方使用
    private static final int DTY=20*60*90;
    public static void main(String[]args){
//        局部常量,只能在本代码块里面使用
        final String a="hello java";
        System.out.println("this is "+Short.MAX_VALUE);
        String b ="hello world";
        System.out.println(b);
        System.out.println(DTY);
        System.out.println(a);

    }
}

我们发现了规律,在Java的程序里面,每一个变量都需要提前声明它的类型,如果是一个文本字符串需要String,如果是一个单字符需要char,注意这里的必须是单引号,整数就是int ,浮点数就是float等。这个程序里面有全局常量和局部的。我们看看运行效果

初识Java之基础语法篇(上)数据类型转换:

byte,short,char—> int —> long—> float —> double

变量与常量

常量
常量是预先定义好的,不可以在后面程序代码里面进行修改的固定值,定义方法一般是大写字母加下划线组成,首字母大写,会使用final关键字进行定义,也会使用static定义一个静态的常量。我们经常使用前者进行定义。

变量
其实变量我们用的更多,对于变量我们要了解一下几个方法

数据类型 变量名 = 数值

在方法之外的变量是需要static修饰不然就会出现问题
我们看看下面的这个代码

package com.company;

public class 变量与常量 {
    private static int a=10;
    private static String b="hello java!!!";
    private static char c='k';
    public static void main(String[]args){
        int d;
        String f;
        f="加油!";d=30;
        int e=a+d;
        e++;
//        变量与常量 b = new 变量与常量();
        System.out.println(e);
        System.out.println(c);
        System.out.println(b);
//        int x=10;
//        int j=++x;
//        System.out.println(x);
    }

}

初识Java之基础语法篇(上)注意这里不在b那里定义一个static这个修饰符,它就会报错,因为这个是方法之外的变量,需要我们修饰。

int a, b, c;         // 声明三个int型整数:a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。
类变量:独立于方法之外的变量,用 static 修饰。
实例变量:独立于方法之外的变量,不过没有 static 修饰。
局部变量:类的方法中的变量。
变量可以先定义不用赋值


public class Variable{
    static int allClicks=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

局部变量声明在方法、构造方法或者语句块中;
局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
访问修饰符不能用于局部变量;
局部变量只在声明它的方法、构造方法或者语句块中可见;
局部变量是在栈上分配的。
局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

Java执行也是从main方法开始执行的额,所以才有了很多的类的基础知识

package com.company;

public class 对象 {
//    这里的age是一个局部变量,它的作用域有限制,所以我们要进行加工处理
    public void pupAge(){
    int age = 0;
    age = age + 7;
    System.out.println("小狗的年龄是: " + age);
}
//在主方法里面进行实现,所以就把上面的类实例化,这样就可以实现了,这个就是类的多次使用
    public static void main(String[] args){
        对象 test = new 对象();
        test.pupAge();
    }
}

初识Java之基础语法篇(上)

实例变量声明在一个类中,但在方法、构造方法和语句块之外;
当一个对象被实例化之后,每个实例变量的值就跟着确定;
实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
实例变量可以声明在使用前或者使用后;
访问修饰符可以修饰实例变量;
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。

类变量

类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
静态变量在第一次被访问时创建,在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
静态变量可以通过:ClassName.VariableName的方式访问。
类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。

运算符

我自己总结一部分比如一些常见的,比较简单的我这里就不枚举了。

递增运算和递减运算符
++a 的意思就是先进行运算,然后在把这个结果给原来的那个变量,当然现在这个变量也是一样的。
a++的意思就是先不运算,先返回一个值,然后把这个值给原来的变量,最后至于这个已经有的变量的值是不变的。

这样说可能有点晦涩难懂,我们直接看一些代码吧


public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

我们只需要注意后面两个了,我这里详细的解释一下,首先d的值为25,进行了后++,那么就是先返回值,后运算,所以现在的打印结果是25,但是这个d的实际值发生了改变为26了,因为进行了运算。

之后我们进行前++,先运算,后返回值,那么就是26+1=27 所以打印的值为27。

现在应该明白了吧!

三元运算符

条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。


public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立,则设置 b 为 20,否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立,则设置 b 为 20,否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

简单的说就是需要对前面的条件进行判断,如果为真,那么结果就是第一个值,为假就是第二个值。
如果后面只有一个值,那么就是为真就直接用之前的值(应该会有数值),如果为假就用后面给的那一个值。

对于Java来说它的运算符还有很多,我这里就不完全的介绍了。学到这里是不是有一种C语言的感觉,不错有些东西就和C语言差不多的。

每文一语

要想做好一件事,就不要去过于的规划太多,有的时候直接出击可能来的更准确!

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。