Java重新开始学习后的笔记——第一章 JAVA基础语法

最新推荐文章于 2023-05-02 20:50:07 发布

阿平23333

最新推荐文章于 2023-05-02 20:50:07 发布

阅读量841

点赞数

分类专栏：基础知识文章标签： java

本文链接：https://blog.csdn.net/lwy23333/article/details/106912326

版权

基础知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

笔记

这里记录一下之前学习Java还没弄懂或者新的发现。

1、数组是储存在堆上的对象，可以保存多个同类型变量。
2、Java中的枚举，限制了变量只能是预先设定好的值。
例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
3、this 本类。
4、接口：接口可理解为对象间互相通信的协议。接口在继承中扮演者很重要的角色。接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
5、自动类型转换与强制类型转换：
自动类型转换必须满足转换前的数据类型的位数要低于转换后的。
转换从低级到高级。
低-------------------------------------------------------------------->高
byte,short,char——>int——>long——>float——>double
数据类型转换必须满足如下规则：
①不能对boolean类型进行类型转换。
②不能把对象类型转换成不相关类的对象。
③在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
④转换过程中可能导致溢出或损失精度，例如：
int i = 128;
byte b = (byte) i;
因为byte类型是8位，最大值为127，所以当int强制转换为byte类型时，值128时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23;
(int)-45.89f == -45;
强制类型的转换用于转换前的数据类型位数高于转换后的。
例如：int i=123;
byte b = (byte) i;//强制类型转换为byte。
6、java局部变量

局部变量声明在方法、构造方法或者语句块中。
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
访问修饰符(public、protected、default、private)不能用于局部变量。
局部变量只在声明它的方法、构造方法、或者语句块中可见。
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
7、java实例变量
实例变量声明在一个类中，但在方法、构造方法和语句块之外。
当一个对象被实例化之后，每个实例变量的值就跟着确定。
实例变量在对象创建的时候创建，在对象被销毁的时候销毁。
实例变量的值应该至少被一个方法、构造方法、或者语句块引用，使得外部能够通过这些方式获取实例变量信息。
实例变量可以声明在使用前或者使用后。
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量变为私有。通过使用访问修饰符可以使实例变量对子类可见。
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
8、类变量(静态变量)
类变量也称为静态变量，在类中以static关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public、private、final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
9、Java修饰符
受保护的访问修饰符-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的方法，不能够被继承。

非访问修饰符

static修饰符
用来修饰类方法和类变量
静态变量：
static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为static变量。
静态方法
static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用classname.viarablename和classname.methodname的方式访问。

final修饰符
final变量：
final表示“最后的、最终的”含义，变量一旦赋值后，不能被重新赋值。被final修饰的实例变量必须显式指定初始值。
final修饰符通常和static修饰符一起使用来创建类常量。
final方法：
父类中的final方法可以被子类继承，但是不能被子类重写。
声明final方法的主要目的是防止该方法的内容被修改。
final类
final类不能被继承，没有类能够继承final类的任何特性。
abstract修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将会出现编译错误。
下面展示一些。

abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast();//抽象方法
public abstract void changeColor();
}

抽象方法：
抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
抽象方法不能被声明成final和static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。

public abstract class SuperClass{
abstract void m();
}
calss SubClass extends SuperClass{
//实现抽象方法
void m(){.............}
}

synchronized修饰符
synchronized关键字声明的方法同一时间只能被一个线程访问。synchronized修饰符可以应用于四个访问修饰符。

public synchronized void showDetails(){
      ................
}

transient修饰符
序列化的对象包含被transient修饰的实例变量时，java虚拟机（JVM）跳过该特定的变量。
public transient int limit = 55; //不会持久化
public int b; //持久化
volatile修饰符
volatile修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个volatile对象引用可能是null。
例：

public class MyRunnable implements Runnable
{
   private volatile boolean active;
   public void run(){
       active = true;
       while(active){  //第一行
            //代码
      }
   }
   public void stop(){
       active = false;   //第二行
   }
}

通常情况下，在一个线程调用run()方法(在Runnable开启的线程)，在另一个线程调用stop()方法。如果第一行中缓冲区的active值被使用，那么在第二行的active值为false时循环不会停止。
但是以上代码中我们使用了volatile修饰active，所以该循环会停止。
9、Java运算符
短路逻辑运算符
当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不再判断第二个操作了。

public class LuoJi{
    public static void main(String[] args){
    int a=5;
    boolean b = (a<4)&&(a++<10)
    System.out.println("使用短路逻辑运算符的结果为"+b);
    System.out.println("a的结果为"+a);
    }
}
运行结果为：
使用短路逻辑运算符的结果为false
a的结果为5

解析：该程序使用到了短路逻辑运算符(&&),首先判断a<4的结果为false，则b的结果必定是false，所以不再执行第二个操作a++<10的判断，所以a的值为5。
条件运算符（？：）
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符主要是决定哪个值应该赋值给变量。

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

int a,b;
a = 10;
//如果a等于1成立，则设置b为20，否则为30
b = (a == 1) ? 20 : 30;

instanceof运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型(类类型或接口类型)。格式：（Object reference variable）instanceof（class/interface type）
例：

String name = "James";
boolean result = name instanceof String; //由于name是String类型，所以返回真。

如果被比较的对象兼容于右侧类型，该运算符仍然返回true。

class Vehicle{}
public class Car extends Vehicle{
   public static void main(String[] args){
       Vehicle a = new Car();
       boolean result = a instanceof Car;
       System.out.println(result);
   }
}

以上实例运行结果为：true。

10、Switch case语句
如果case语句块中没有break语句时，匹配成功后，从当前case开始，后续所有case的值都会输出。例：

int i=1;
switch(i){
   case 0;
      System.out.println("0");
   case 1;
      System.out.println("1");
   case 2;
      System.out.println("2");
   default:
      System.out.println("default");
}

运行结果：

   1
   2
   default

如果当前匹配成功的case语句块没有break语句，则从当前case开始，后续所有case的值都会输出，如果后续的case语句块有break语句则会跳出判断

int i=1;
switch(i){
   case 0;
      System.out.println("0");
   case 1;
      System.out.println("1");
   case 2;
      System.out.println("2");
      break;
   default:
      System.out.println("default");
}

运行结果：

   1
   2

11、java循环结构
Java增强for循环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(",");
      }
   }
}

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

break关键字
break主要用在循环语句或者switch语句中，用来跳出整个语句块。
break跳出最里层的循环，并且继续执行该循环下面的语句。
实例：

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

以上实例编译运行如下：

10
20

continue关键字
continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在for循环中，continue语句使程序立即跳转到更新语句。
在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。
实例：

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

以上实例编译运行结果如下：

12、Java数组
声明数组变量

dataType[] arrayRefVar;      //首选的方法
dataType arrayRefVar[];      //效果相同，但不是首选方法

注意：建议使用dataType[] arrayRefVar的声明风格声明数组变量。

//实例
double[] myList;          //首选的方法
double myList[];          //效果相同，但不是首选方法

创建数组
Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[];

上面的语法语句做了两件事：

使用dataType[arraySize]创建了一个数组。
把新创建的数组的引用赋值给变量arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0,value1,...,valuen};

数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length-1。
For-Each循环
For-Each循环也叫做加强型循环，它能在不使用下标的情况下遍历数组。
格式如下：

for(type element:array){
   System.out.println(element);
}

实例：

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

以上实例编译运行结果如下：

1.9
2.9
3.4
3.5

数组作为函数的参数
数组可以作为参数传递给方法。
例如，下面的例子就是一个打印int数组中元素的方法：

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

下面例子调用 printArray 方法打印出 3，1，2，6，4 和 2：

printArray(new int[]{3, 1, 2, 6, 4, 2});

数组作为函数的返回值：

public static int[] reverse(int[] list){
  int[] result = new int[list.length];
  
  for(int i = 0,j = result.length - 1; i < list.length; i++, j--){
    result[j] = list[i];
  }
    return result;
}

以上实例中result数组作为函数的返回值。

Arrays类
java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：

给数组赋值：通过fill方法。
对数组排序：通过sort方法。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

13、Java方法
在前几章中我们经常使用到System.out.println(),那么它是什么呢？

println()是一个方法。
System是系统类。
out是标准输出对象。

这句话的用法是调用系统类System中的标准输出对象out中的方法println()。

那么什么是方法呢？
Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序集合。
方法包含于类或对象中。
方法在程序中被创建，在其他地方被引用。

方法的优点

使程序变得更简短而清晰。
有利于程序维护。
以提高程序开发的效率。
提高了代码的重用性。

方法的命名规则

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
下划线可能出现在JUnit测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如testPop_emptyStack。

方法的定义
一般情况下，定义一个方法包含以下语法：

修饰符 返回值类型 方法名(参数类型 参数名){
     ...
     方法体
     ...
     return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分。

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字Void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。

如：public static int age(int birthday){.....}
参数可以有多个：static float interest(float principle, int year){..}

方法调用
Java支持两种调用方法的方式，根据方法是否返回值来选择。
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30 , 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是条语句。

System.out.println("欢迎访问牛客教程！");

通过值传递参数
调用一个方法有时候需要提供参数，必须按照参数列表指定的顺序提供。
示例：

public class TestPassByValue {
  public static void main(String[] args) {
    int num1 = 1;
    int num2 = 2;
 
    System.out.println("交换前 num1 的值为：" +
                        num1 + " ，num2 的值为：" + num2);
 
    // 调用swap方法
    swap(num1, num2);
    System.out.println("交换后 num1 的值为：" +
                       num1 + " ，num2 的值为：" + num2);
  }
  /** 交换两个变量的方法 */
  public static void swap(int n1, int n2) {
    System.out.println("\t进入 swap 方法");
    System.out.println("\t\t交换前 n1 的值为：" + n1
                         + "，n2 的值：" + n2);
    // 交换 n1 与 n2的值
    int temp = n1;
    n1 = n2;
    n2 = temp;
 
    System.out.println("\t\t交换后 n1 的值为 " + n1
                         + "，n2 的值：" + n2);
  }
}

以上实例编译运行结果如下：

交换前 num1 的值为：1 ，num2 的值为：2
    进入 swap 方法
        交换前 n1 的值为：1，n2 的值：2
        交换后 n1 的值为 2，n2 的值：1
交换后 num1 的值为：1 ，num2 的值为：2

可以发现，传递两个参数的swap方法，方法被调用后，实参的值并没有变。

方法的重载
上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点型数据的最大值呢？解决方法是创建另一个有相同名字但参数不同的办法，如下面代码所示：

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；

如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；

就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

Java编译器根据方法签名判断哪个方法应该被调用。

方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。

重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

变量作用域
变量的范围是程序中该变量可以被引用的部分。
方法内定义的变量被称为局部变量。
局部变量的作用范围从声明开始，直到包含它的块结束。
局部变量必须声明才可以使用。
方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
for循环的初始化部分声明的变量，其作用范围在整个循环。
但循环体内声明的变量其适用范围是从它声明到循环结束。它包含如下所示的变量声明：
在这里插入图片描述
你可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量，但你不能在嵌套块内两次声明局部变量。

命令行参数的使用
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。

实例：
下面的程序打印所有的命令行参数：

public class CommandLine {
   public static void main(String args[]){
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " + args[i]);
      }
   }
}

如下所示，运行这个程序：

$ javac CommandLine.java
$ java CommandLine this is a command line 200 -100
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

构造方法
当一个对象被创建的时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为public，构造函数也为public。类为private，构造函数也为private。)

一旦你定义了自己的构造方法，默认构造方法就会失效。

实例
下面是一个使用构造方法的例子：

//一个简单的构造函数
class MyClass{
    int x;
     
    //以下是构造函数
    MyClass(){
       x = 10;
   }
}

你可以像下面这样调用构造方法来初始化一个对象：

public class ConsDemo{
   public static void main(String args[]){
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x) 
   }
}

大多时候需要一个有参数的构造方法。

实例
下面是一个使用构造方法的例子：

//一个简单的构造函数
class MyClass{
   int x;
    
   //以下是构造函数
   MyClass(int i){
      x=i; 
   }
}

你可以像下面这样调用构造方法来初始化一个对象：

public class ConsDemo{
  public static void main(String args[]){
     MyClass t1 = new MyClass(10);
     MyClass t2 = new MyClass(20);
     System.out.println(t1.x + " " + t2.x); 
  }
}

运行结果如下：
10 20

可变参数
Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明：typeName...parameterName
在方法声明中，在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

实例

public class VarargsDemo {
    public static void main(String args[]) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
 
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

运行结果如下：

The max value is 56.5
The max value is 3.0

finalize()方法
Java允许定义这样的方法，它在对象被垃圾收集器析构(回收)前调用，这个方法叫做finalize()，它用来清除回收对象。
例如，你可以使用finalize()来确保一个对象打开的文件被关闭了。
在finalize()方法里，你必须指定在对象销毁时候要执行的操作。
finalize()一般格式是：

protected void finalize(){
   //在这里终结代码
}

关键字protected是一个限定符，它确保finalize()方法不会被类以外的代码调用。

当然，Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的办法。

实例

public class FinalizationDemo { 
  public static void main(String[] args) { 
  
    } 
} 
 
 class Cake extends Object{
    private int id;
    public Cake(int id){
      this.id = id;
      System.out.println("Cake Object " + id +"is created"); 
    } 
     
    protected void finalize() throws java.lang.Throwable{
       super.finalize();
       System.out.println("Cake Object " + id + "is disposed"); 
    }
}

运行以上代码，输出结果如下：

$ javac FinalizationDemo.java
$ java FinalizationDemo
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed

14、Java Scanner类
Scanner类用来获取用户的输入，下面是创建Scanner对象的基本语法：

Scanner s = new Scanner(System.in);

接下来我们演示一个最简单的数据输入，并通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext与hasNextLine判断是否还有输入的数据：

使用next方法

import java.util.Scanner;

public class ScannerDemo{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        //从键盘接收数据
         
        //next方式接收字符串
        System.out.println("next方式接收：");
        //判断是否还有输入
        if(scan.hasNext()){
           String str1 = scan.next();
           System.out.println("输入的数据为：" + str1); 
        }
        scan.close();
    }
}

执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
nowcoder com
输入的数据为：nowcoder

可以看到com字符串并未输出，接下来我们看nextLine。

使用nextLine方法：

import java.util.Scanner;

public class ScannerDemo{
   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); 
       } 
       scan.close();
   }
}

执行以上输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
nowcoder com
输入的数据为：nowcoder com

可以看到com字符串输出。

next()与nextLine()区别
next();

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

nextLine();

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

如果要输入int或float类型的数据，在Scanner类中也有支持，但是在输入之前最好先使用hasNextXxx()方法进行验证，再使用nextXxx()来读取。

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.print("输入整数：");
        if (scan.hasNextInt()) {
            // 判断输入的是否是整数
            i = scan.nextInt();
            // 接收整数
            System.out.println("整数数据：" + i);
        } else {
            // 输入错误的信息
            System.out.println("输入的不是整数！");
        }
        System.out.print("输入小数：");
        if (scan.hasNextFloat()) {
            // 判断输入的是否是小数
            f = scan.nextFloat();
            // 接收小数
            System.out.println("小数数据：" + f);
        } else {
            // 输入错误的信息
            System.out.println("输入的不是小数！");
        }
        scan.close();
    }
}

执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
输入整数：12
整数数据：12
输入小数：1.2
小数数据：1.2

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

import java.util.Scanner;
 
class ScannerDemo {
    public static void main(String[] args) {
        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();
  }
}

执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
12
23
15
21.4
end
4个数的和为71.4
4个数的平均值是17.85

欢迎使用Markdown编辑器

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法¹ 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

~~删除文本~~

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片: Alt

带尺寸的图片:

居中的图片: Alt

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

项目
- 项目
  - 项目

项目1
项目2
项目3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	‘Isn’t this fun?’
Quotes	`"Isn't this fun?"`	“Isn’t this fun?”
Dashes	`-- is en-dash, --- is em-dash`	– is en-dash, — is em-dash

创建一个自定义列表

Markdown

Text-to- HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma(n) = (n-1)!\quad\forall n\in\mathbb N$ 是通过欧拉积分

$\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,.$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

关于 甘特图 语法，参考这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

关于 Mermaid 语法，参考这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

关于 Flowchart流程图 语法，参考这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

mermaid语法说明 ↩︎
注脚的解释 ↩︎

阿平23333

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java重新开始学习后的笔记——第一章 JAVA基础语法

笔记这里记录一下之前学习Java还没弄懂或者新的发现。1、数组是储存在堆上的对象，可以保存多个同类型变量。2、Java中的枚举，限制了变量只能是预先设定好的值。例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。3、this 本类。4、接口：接口可理解为对象间互相通信的协议。接口在继承中扮演者很重要的角色。接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。5、自动类型转换与强制类型转换：自动类型转换必须满足转换前的数据
复制链接

扫一扫