Java语法篇

月色不心动

已于 2022-08-10 21:43:02 修改

阅读量155

点赞数 1

分类专栏： Java 文章标签： java

于 2021-07-12 01:58:41 首次发布

本文链接：https://blog.csdn.net/EricItman/article/details/118650887

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一，关键字和标识符

1.关键字

（1）定义：Java语言的关键字是程序代码中的特殊字符，每个关键字都有特殊的作用，例如package用于包的声明，import用于引入包，class声明一个类等。

（2）分类：以下是对Java目前定义的51个关键字的分类。

数据类型：boolean、int、long、short、byte、float、double、char、class、interface
    
流程控制：if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally
    
修饰符：public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native
    
动作：package、import、throw、throws、extends、implements、this、supper、instanceof、new
    
保留字：true、false、null、goto、const

（3）使用关键字时要注意的地方：

所有的关键字都是小写
friendly、sizeof不是Java的关键字，有别于C++
程序中的标识符不能以关键字命名

2.标识符

（1）定义：标识符是指程序中包、类、接口、变量或方法的名字。

（2）使用规则：

标识符的首字符必须是字母、下划线（_）、符号&或者￥。
标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）组合构成（各符号之间没有空格）。
标识符没有长度的限制。
不能把关键字和保留字作为标识符。
标识符是大小写敏感的。

二、数据类型和变量

1.数据类型

数据类型可以分为基本类型和引用类型，使用不同的数据类型是依据数据精度和空间使用率决定的，

（1）八大基本类型

基本数据类型及取值范围
数据类型	关键字	在内存中占用的字节数	取值范围	默认值
布尔型	boolean	1个字节（8位）	true、false	false
字节型	byte	1个字节（8位）	-128~127	0
字符型	char	2个字节（16位）	0~2^16-1	'\u0000'
短整型	short	2个字节（16位）	-2^15~2^15-1	0
整型	int	4个字节（32位）	-2^31~2^31-1	0
长整型	long	8个字节（64位）	-2^63~2^63-1	0
单精度浮点型	float	4个字节（32位）	1.4E-45~3.403E38	0.0F
双精度浮点型	double	8个字节（64位）	4.9E-324~1.798E308	0.0D

(2)引用类型

（3）类型转换规则

小容量向大容量转换叫做自动类型转换：byte<char<short<int<long<float<double

        int a=10;
        double b=a;  //正确，小容量转换成大容量

        double c=9.0;
        int d=c;     //错误，大容量无法自动转换成小容量

大容量向小容量转换是强制类型转换，需要加强制转换符

        double c=9.0;
        int d=(int)c;   //大容量转换成小容量,使用强制方法

多种数据类型做混合运算，先转换成容量最大的那种再做运算，当表达式内最大容量小于int时，将转换成int类型运算。

short x=1,y=1;
int sum=x+y;   //x+y自动转换成int类型计算，结果不属于short类型，应该为int类型
System.out.println(d+c+a);  //表达式最大容量是double 所以自动转换成double类型运算

2.变量

（1）变量定义：变量是内存中的一个存储区域，该区域有自己的变量名、数据类型和值，该区域的数据范围即是数据类型的范围，所以在Java中每个变量必须先声明，再赋值，然后才能使用。

（2）Java 中的变量有四个基本属性：变量名，数据类型，存储单元和变量值

变量名：合法的标识符
变量的数据类型：可以是基本类型和引用类型（必须包含类型）
变量值：在存储单元中放的就是变量值（如果是基本类型放的就是具体值，如果是引用类型放的是内存地址，如果null，表示不指向任何对象）
定义变量的格式：数据类型变量名 = 初始化值

（3）变量按声明位置的不同可以分为成员变量和局部变量

在方法体外，类体内声明的变量是成员变量
在方法体内声明的变量是局部变量

（4）注意事项

在同一个作用域内不允许定义同名的多个变量，例如不允许定义两个同名的成员变量。
在不同的作用域允许定义同名的变量，例如两个不同的代码块，但在方法内定义了和成员变量同名的局部变量或参数，这个实例变量将被屏蔽，若要访问要使用关键字this 访问。
静态变量生命周期取决于类的创建和销毁，实例变量生命周期取决于实例的创建和销毁，局部变量则取决于方法的被调用和结束调用。

三、运算符与修饰符

1.运算符

（1）算术运算符

（2）关系运算符

（3）逻辑运算符

（4）赋值运算符

（5）条件运算符（?:）也称三元运算符

variable x = (expression) ? value if true : value if false

选出两个数中的较大值
int a=10,b=20;
int a= (c>b)?c:b   //如果c>b 则较大值为c 否则为b

（6）位运算符

2.修饰符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符
非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：

public class ClassName {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

访问控制
修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

下面的类使用了私有访问修饰符：

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

接口及接口的成员变量和成员方法不能声明为 protected。可以看看下图演示：

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。

如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

访问控制和继承

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

static 修饰符

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符

final 变量：

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。

声明 final 方法的主要目的是防止该方法的内容被修改。

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

四、流程控制

基于C语言相似的for、while、do.....while、switch-case等流程控制不作描述。

1.Java 增强 for 循环

/*
for(声明语句 : 表达式)
{
   //代码句子
}

*/

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

五、String类

1.创建字符串关键字：String

/* 创建字符串方法  */

String str1;

String str2 = "Lee";   //直接创建

String str3 = new String ("Hello World！")   //String对象创建

2.String 类的一个方法是 length() 方法，它返回字符串对象包含的字符数。

int len = str2.length();  //str2 的长度是3

3.连接字符串

使用方法 .concat()
使用“+”连接字符串

str2.concat(str3);

String str4 = str2+str3;

.4.常用的一些方法：.equals(String)、.equalsIgnoreCase(String）、isEmpty()等

六、数组与Array类

1.数组是一个很重要的数据结构，基本用法和C语言相似，不再重复描述。

2.声明变量->创建变量->使用变量

dataType[] arrayRefVar = new dataType[arraySize];

3.Array类

七、Scanner类

1.java.util.Scanner,可以通过 Scanner 类来获取用户的输入。

2.创建Scanner:

Scanner s = new Scanner(System.in);

3.通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据，两者的区别：

next():

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine()：

以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

import java.util.Scanner;

public class Lee2 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据

        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("输入的数据为：" + str1);
        }
        scan.close();
    }
}

结果如下：

此外，若是需要输入int或其他数据类型，同理可用hasNextXxx()和nextXxx来判断且输入

例如输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：

import java.util.Scanner;

class LeeScanner {
    public static void main(String[] args) {
        System.out.println("请输入数字：");
        Scanner scan = new Scanner(System.in);

        double sum = 0;
        int m = 0;

        while (scan.hasNextDouble()) {
            double x = scan.nextDouble();
            m = m + 1;
            sum = sum + x;
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));
        scan.close();
    }
}

结果如下：

八、面向对象基础知识

学期小结：

java三大特性：继承、封装、多态。

1.类与对象

（1）程序的对象定义：一组属性和相关方法的集合。

现实的对象定义：可数字化描述的复杂事物。

（2）抽象：将共同行为特征提取出来的过程。

（3）类的定义：抽象的数据类型，包含类名、属性、方法三要素。

（4）类与对象的关系：类是对象的模板，对象是类的实例。

2.方法

（1）方法依赖于对象的属性。

（2）方法分类：

构造方法：初始化属性，与类同名，无返回值。
存取方法：Set、Get函数名开头，修改属性值。
功能方法：调用属性。

（3）方法重载：同一个类中两个及以上的方法允许同名，但参数的类型或数量不能相同。

3.继承（Inheritance）

（1）继承的定义：java之继承，犹如人之继承，子承父类，却有异同。java的继承打破了封装，实现了拓展，是解决面向对象信息耦合问题的一方法。

（2）继承过程：

子类会拥有父类除构造方法外的所有属性和方法，并有独立属性，更新父类方法。
子类需要通过关键字 extends 继承一个类，且是一个子类只能继承一个父类，而一个父类可以有多个子类。
父类中被声明private的成员可继承不可访问。
关键字 super（），放在子类构造方法内第一行可以改变修改构造方法。

（3）覆盖：继承时，子类定义的方法三要素（名称、参数、返回值）与父类的相同，将覆盖父类的函数。

（4）抽象类：

关键字abstract
一个抽象类不能通过new直接实体化，不能定义抽象构造函数和静态方法。
若有一个方法是抽象方法则该类一定要声明为抽象类。
子类必须覆盖父类所有的抽象方法。

4.接口（Interface）

（1）定义：是一种只有方法没有属性的抽象类，实现一个类的多继承。

（2）类继承接口，使用关键字 implements

5.异常处理

（1）异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

（2）异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。

（3）要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

（4）使用try-catch捕获异常

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

catch 不能独立于 try 存在。
在 try/catch 后面添加 finally 块并非强制性要求的。
try 代码后不能既没 catch 块也没 finally 块。
try, catch, finally 块之间不能添加任何代码。

（5）throws/throw 关键字：

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

下面方法的声明抛出一个 RemoteException 异常：

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

月色不心动

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java语法篇

一，关键字和标识符1.关键字（1）定义：Java语言的关键字是程序代码中的特殊字符，每个关键字都有特殊的作用，例如package用于包的声明，import用于引入包，class声明一个类等。（2）分类：以下是对Java目前定义的51个关键字的分类。数据类型：boolean、int、long、short、byte、float、double、char、class、interface 流程控制：if、else、do、while、for、switch、case、default、break...
复制链接

扫一扫