JAVA语言关键字

java中when的用法# Java中when的用法在Java编程语言中，`when`是一个关键字用于控制程序的流程和决策。

`when`关键字主要用于`switch`语句的替代，使代码更加简洁和易读。

## `when`语法下面是`when`语句的基本语法：```javawhen (expression) {case value1:// 执行操作1break;case value2:// 执行操作2break;case value3:// 执行操作3break;default:// 执行默认操作}```在`when`语句中，`expression`指的是需要进行匹配的值。

后面紧跟着一系列`case`，每个`case`后面是需要匹配的值。

如果匹配成功，则执行相应`case`下的代码块。

如果没有匹配成功，则会执行`default`块中的代码。

## 示例让我们来看一个简单的示例，说明在Java中如何使用`when`语句：```javaString day = "Sunday";when (day) {case "Monday":System.out.println("今天是星期一");break;case "Tuesday":System.out.println("今天是星期二");break;case "Wednesday":case "Thursday":System.out.println("今天是星期三或星期四");break;case "Friday":System.out.println("今天是星期五");break;case "Saturday":case "Sunday":System.out.println("今天是星期六或星期天");break;default:System.out.println("无效的日期");}```在以上示例中，根据`day`的值，会输出不同的提示信息。

最最常用的关键词及音标数据类型：boolean、byte、short、int、long、double、char、float、double。

包引入和包声明：import、package。

用于类和接口的声明：class、extends、implements、interface。

流程控制：if、else、switch、do、while、case、break、continue、return、default、while、for.异常处理：try、catch、finally、throw、throws。

修饰符：abstract、final、native、private、protected、public、static、synchronized、transient、volatile。

其他：new、instanceof、this、super、void、assert、const*、enum、goto＊、strictfp。

Java基础常见英语词汇（共70个)［'ɔbdʒekt］［'ɔ：rientid]导向的［'prəʊɡræmɪŋ]编程OO：object-oriented ,面向对象OOP：object-oriented programming,面向对象编程［dɪ’veləpmənt][kɪt]工具箱['vɜːtjʊəl]虚拟的JDK：Java development kit，java开发工具包JVM:java virtual machine ,java虚拟机［'dʒɑːvə］[mə’ʃiːn]机器[kəm'paɪl］Compile:编绎Run：运行['veərɪəb(ə）l］［ɒpə'reɪʃ（ə）n］[pə’ræmɪtə］variable:变量operation：操作，运算parameter:参数［’fʌŋ(k)ʃ（ə）n］function:函数member-variable:成员变量member-function：成员函数[dɪ’fɔːlt] ［’ækses］[’pækɪdʒ] ［ɪm’pɔːt］［’stætɪk］default：默认access:访问package:包import:导入static：静态的[vɔid］[’peər(ə)nt］［beɪs] ['sjuːpə］void:无(返回类型）parent class：父类base class：基类super class：超类［tʃaɪld］[di’raivd][əʊvə'raɪd] ［əʊvə'ləʊd] child class:子类derived class：派生类override:重写，覆盖overload：重载['faɪn（ə)l] ［'ɪmplɪm(ə）nts]final:最终的,不能改变的implements:实现[rʌn’taim]［æriθ’metik] ［ik'sepʃən］Runtime：运行时ArithmeticException：算术异常［ə'rei］［'indeks］[baundz] [ik'sepʃən］[nʌl] ['pɔintə]指针ArrayIndexOutOfBoundsException:数组下标越界异常Null Pointer Exception：空引用异常ClassNotFoundException：类没有发现异常［'nʌmbə］［'fɔ:mæt］NumberFormatException:数字格式异常(字符串不能转化为数字）[θrəuz]Throws: (投掷)表示强制异常处理Throwable：(可抛出的）表示所有异常类的祖先类［læŋ］['læŋɡwidʒ]［ju'til] [，dis’plei］[ə’rei] [list]Lang：language，语言Util:工具Display:显示ArrayList：（数组列表）表示动态数组［hæʃ］[mæp]HashMap：散列表，哈希表[swiŋ] ［'æbstrækt] ['windəu］［'tu:lkit］Swing:轻巧的Awt：abstract window toolkit:抽象窗口工具包[freim] ［'pænl] [’leiaut]［skrəul] ［’və:tikəl］Frame：窗体Panel：面板Layout：布局Scroll：滚动Vertical:垂直［’hɔri'zɔntəl] [’leibl］［tekst] ［’fi：ld］Horizontal：水平Label：标签TextField：文本框['εəriə] ['bʌtən］[tʃek] ［bɔks］TextArea：文本域Button：按钮Checkbox：复选框[’reidiəu］['kɔmbəu] ［’lisənə］Radiobutton：单选按钮C ombobox:复选框Listener:监听['bɔ:də］［fləu］[ɡrid］['menju：] [bɑ：］Border：边界Flow：流Grid：网格MenuBar:菜单栏[’menju:］［’aitəm] ［'pɔpʌp］Menu:菜单MenuItem:菜单项PopupMenu:弹出菜单['daiəlɔɡ] [’mesidʒ] ['aikɔn] [nəud］Dialog:对话框Message:消息Icon：图标Node：节点［’dʒa：və] ［'deitəbeis］［，kɔnek’tivəti]Jdbc：java database connectivity ：java数据库连接［draivə] ['mænidʒə］ [kə’nekʃən］['steitmənt］DriverManager：驱动管理器Connection：连接Statement：表示执行对象[pri’peəd］[ri’zʌlt]Preparedstatement：表示预执行对象Resultset：结果集['eksikju:t] ['kwiəri]executeQuery：执行查询334157810 这群每日java技术免费分享定期java资料更新Jbuilder中常用英文(共33个)［kləuz] [ik'sept］[peinz]Close all except…:除了。

Java中的关键字有哪些？1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

1.访问修饰符的关键字（3个）public（公有的）：可跨包protected (受保护的)：当前包内可⽤private (私有的)：当前类可⽤2.定义类、接⼝、抽象类和实现接⼝、继承类的关键字、实例化对象（6个）class (类)：public class A(){}花括号⾥是已实现的⽅法体，类名需要与⽂件名相同interface (接⼝)：public interface B(){}花括号⾥有⽅法体，但没有实现，⽅法体句⼦后⾯是英⽂分号“;”结尾 abstract (声明抽象)：public abstract class C(){}介于类与接⼝中间，可以有，也可以没有已经实现的⽅法体implements (实现)：⽤于类或接⼝，实现接⼝public class A interface B(){} extends (继承)：⽤于类继承类public class A extends D(){}new (创建新对象)：A a=new A();A表⽰⼀个类3.包的关键字（2个）import (引⼊包的关键字)：当使⽤某个包的⼀些类时，仅需要类名，即可⾃动插⼊类所在的包package (定义包的关键字)：将所有相关的类放在⼀个包类以便查找修改等4.数据类型的关键字（9个）byte (字节型)：8bitchar (字节型)：16bitboolean (布尔型)：--short (短整型)：16bitint (整型)：32bitfloat (浮点型)：32bitlong (长整型)：64bitdouble (双精度)：64bitvoid (⽆返回)：public void A(){}其他需要反回的经常与return连⽤5.条件循环（流程控制）（12个）if (如果) ：if（条件语句｛执⾏代码｝如果条件语句成⽴，就开始执⾏｛｝⾥⾯的内容else (否则，或者) ：常与if连⽤，⽤法相同：if(...){...}else{...}while (当什么时候)：while（条件语句）｛执⾏代码｝for（满⾜三个条件时）：for(初始化循环变量；判断条件；循环变量值｛｝switch (选择结构)：switch(表达式）｛case常量表达式1：语句1；...case常量表达式2；语句2；default:语句；｝default就是如果没有匹配的case就执⾏它，default并不是必须的。

java的perform用法-回复Java的perform用法:Java是一种面向对象的编程语言，用于开发跨平台的应用程序。

在Java 中，perform是一个关键字，用于执行方法或代码块。

它可以用于实现各种功能，包括实例化对象、调用方法、处理异常等。

在本文中，我将详细介绍perform的用法，并提供一些使用示例。

1. 实例化对象：在Java中，perform可以用于实例化一个类的对象。

以下是一个示例：perform MyObject obj = new perform MyObject();上述代码创建了一个名为obj的MyObject类的对象。

你可以使用obj 对象调用该类中的方法或访问其属性。

2. 调用方法：可以使用perform关键字来调用类的方法。

以下是一个示例：perform obj = new perform();obj.methodName();上述代码创建了一个名为obj的实例，并调用了该实例中的methodName方法。

可以根据需要添加参数。

3. 处理异常：在Java中，perform关键字也可用于处理异常。

以下是一个示例：perform try {可能会发生异常的代码} catch (Exception e) {异常处理代码}在上述示例中，try块用于包裹可能会发生异常的代码。

如果发生异常，控制流将转移到catch块，其中可以编写异常处理代码。

请注意，你可以根据需要添加多个catch块，以处理不同类型的异常。

4. 使用Lambda表达式：Java 8引入了Lambda表达式，它可以通过perform关键字来实现。

Lambda表达式允许你以更简洁的方式编写匿名函数。

以下是一个使用Lambda表达式和perform关键字的示例：perform myLambda = () -> {执行代码块};在上述示例中，myLambda是一个perform对象，它保存了一个执行代码块的Lambda表达式。

java extends用法Java语言中extends是一个关键字，它表示子类继承父类的关系。

Java的类继承机制在面向对象编程中非常重要和常见，它使得我们可以通过在已有类的基础上创建新的类，而无需再次编写相同的代码。

在接下来的文章中，我将详细介绍Java中extends的用法，并提供一些实例来帮助读者更好地理解。

1. extends的定义在Java中，extends是一个关键字，用于创建一个新的类。

当我们使用extends关键字来定义一个新的类时，我们实际上是创建了一个子类，继承了一个或多个已有的父类。

子类可以继承父类的属性和方法，也可以通过添加自己的属性和方法来扩展自己的功能。

在Java中使用extends时，子类应该在关键字extends后加上父类的名称。

例如，如果我们要创建一个名为"ChildClass"的子类，并继承自一个名为"ParentClass"的父类，我们应该使用以下代码：```public class ChildClass extends ParentClass{//子类的代码}``````public class Animal{public void move(){System.out.println("Animal can move");}}在上面的例子中，我们定义了两个类，一个是Animal类，它有一个move()方法，输出"Animal can move"；另一个是Dog类，它继承了Animal类，重写了move()方法，并新增了一个bark()方法，输出"Dog can bark"。

现在我们可以创建一个Dog对象，并使用它的方法：运行上面的代码，输出结果为：```Animal can moveDog can run and walkDog can bark```上面的代码演示了继承的一个基本概念：子类可以使用父类的方法，重写父类的方法，并新增自己的属性和方法。

关键字作用访问控制private私有的protected受保护的public公共的类、方法和变量修饰符abstract声明抽象class类extends继承、扩展final最终、不可改变implements实现interface接口native本地new新,创建static静态strictfp严格,精准synchronized线程、同步transient短暂volatile易失程序控制语句break跳出，中断continue继续return返回do运行while循环if如果else否则for循环instanceof实例switch观察case返回观察里的结果default默认错误处理try捕获异常catch处理异常throw抛出一个异常对象throws声明一个异常可能被抛出包相关import引入package包基本类型boolean布尔型byte字节型char字符型double双精度float浮点int整型long长整型short短整型null空TRUE真FALSE假变量引用super父类,超类this本类void无返回值保留字goto跳转const静态native本地详细说明private 关键字是访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）。

只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。

在类的外部protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。

可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。

可能只会在其他任何类或包中引用 public 类、方法或字段。

所有类成员的默认访问范围都是abstract关键字可以修改类或方法。

abstract类可以扩展（增加子类），但不能直接实例化。

abstract方法不在声明它的类中实现，但必须在某个子类中重写。

java super 关键字调用父类的构造方法与方法的用法和注意事项一、背景介绍在Java中，super关键字是一个非常重要的关键字，它用于调用父类的构造方法和方法。

在面向对象的程序设计中，经常会遇到需要在子类中重写父类的方法或者调用父类的构造方法的情况。

而super关键字就是用来处理这些情况的。

二、什么是super关键字super关键字是Java中的一个关键字，它用来调用父类的构造方法和方法。

在子类中通过super关键字可以访问父类中的成员变量和方法，以及调用父类的构造方法。

三、调用父类的构造方法在Java中，当子类实例化的时候，其构造方法会自动调用父类的无参构造方法。

但如果父类没有无参构造方法，那么子类就需要通过super关键字来调用父类的有参构造方法。

例如：javapublic class Parent {public Parent(int num) {父类的有参构造方法}public class Child extends Parent {public Child(int num) {super(num); 调用父类的有参构造方法}}需要注意的是，super关键字在子类构造方法中必须是第一条语句，否则编译器会报错。

因为在实例化子类的时候，先要调用父类的构造方法，然后再执行子类的构造方法。

四、调用父类的方法除了调用父类的构造方法，super关键字还可以用来调用父类的方法。

在子类中可以使用super关键字来访问父类中的普通方法或者重写父类的方法。

例如：javapublic class Parent {public void method() {父类的方法}public class Child extends Parent {public void method() {super.method(); 调用父类的方法}}在这个例子中，子类重写了父类的方法，然后在子类方法中通过super关键字调用了父类的方法。

Java 48个关键字总结珍藏版1.abstract Java 关键字abstract 关键字可以修改类或方法。

abstract 类可以扩展（增加子类），但不能直接实例化。

abstract 方法不在声明它的类中实现，但必须在某个子类中重写。

示例public abstract class MyClass{}public abstract String myMethod();注释采用abstract 方法的类本来就是抽象类，并且必须声明为abstract。

abstract 类不能实例化。

仅当abstract 类的子类实现其超类的所有abstract 方法时，才能实例化abstract 类的子类。

这种类称为具体类，以区别于abstract 类。

如果abstract 类的子类没有实现其超类的所有abstract 方法，该子类也是abstract 类。

abstract 关键字不能应用于static、private 或final 方法，因为这些方法不能被重写，因此，不能在子类中实现。

final 类的方法都不能是abstract，因为final 类不能有子类。

2.boolean 变量的值可以是true 或false。

示例boolean valid = true;if (valid){<statement>}注释boolean 变量只能以true 或false 作为值。

boolean 不能与数字类型相互转换。

包含boolean 操作数的表达式只能包含boolean 操作数。

Boolean 类是boolean 原始类型的包装对象类3.break 关键字用于提前退出for、while 或do 循环，或者在switch 语句中用来结束case 块。

示例for (i=0; i<max; i++){if (<loop finished early>){break;}}int type = <some value>;switch (type){case 1:<statement>break;case 2:<statement>break;default:<statement>}注释break 总是退出最深层的while、for、do 或switch 语句。

另外，使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。

举例1：class Person{ // 定义Person类public void speak(){System.out.println(“年龄：”+this.age);}}举例2：public class Rectangle {int length;int width;public int area() {return this.length*this.width;}public int perimeter(){return2* (this.length+this.width);}public void print(char sign) {for (int i=1; i<=this.width; i++) {for (int j=1; j<=this.length; j++) {System.out.print(sign);}System.out.println();}}public String getInfo(){return"长："+this.length+"，宽："+this.width+"，面积："+ this.area() +"，周长："+this.perimeter();}}测试类：public class TestRectangle {public static void main(String[] args) {Rectangle r1=new Rectangle();Rectangle r2=new Rectangle();System.out.println("r1对象："+r1.getInfo());System.out.println("r2对象："+r2.getInfo());r1.length=10;r1.width=2;System.out.println("r1对象："+r1.getInfo());System.out.println("r2对象："+r2.getInfo());r1.print('#');System.out.println("---------------------");r1.print('&');System.out.println("---------------------");r2.print('#');System.out.println("---------------------");r2.print('%');}}1.2.2 同一个类中构造器互相调用this可以作为一个类中构造器相互调用的特殊格式。

Java关键字（keywords）abstract default if private thisboolean do implements otected throwbreak double import public throwsbyte else instanceof return transientcase extends int short trycatch final interface static voidchar finally long strictfp volatileclass float native super whileconst for new switchcontinue goto package synchronized以上是java specifications中定义的keywords，一共48个，其中常见的三个看似是关键字的true, false, null,都不是关键字，而是作为一个单独标识类型。

其中，不常用到的关键字有：const，goto，native，strictfp，transient，volatile。

const和goto为java中的保留字。

1. nativenative是方法修饰符。

Native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法。

因为在外部实现了方法，所以在java代码中，就不需要声明了，有点类似于借口方法。

Native可以和其他一些修饰符连用，但是abstract方法和Interface方法不能用native来修饰。

Example：Java代码1.public interface TestInterface {2. void doMethod();3.}4.public class Test implements TestInterface {5. public native void doMethod();6. private native int doMethodB();7.public native synchronized String doMethodC();8.static native void doMethodD();9.}为什么需要使用native method？请参考：/topic/72543 java Native Method初涉2. strictfp修饰类和方法，意思是FP-strict，精确浮点，符合IEEE-754规范的。

java中protect用法摘要：1.Java 中的保护关键字2.protect 用法示例3.保护关键字的作用正文：1.Java 中的保护关键字在Java 编程语言中，保护（protect）是一种访问控制修饰符，用于限制对类成员（变量和方法）的访问。

使用保护关键字可以控制其他类对方法的访问，以实现数据隐藏和封装。

2.protect 用法示例下面是一个使用保护关键字的Java 示例：```javaclass Person {protected String name;protected int age;protected void setName(String name) { = name;}protected void setAge(int age) {this.age = age;}public String getName() {return name;}public int getAge() {return age;}}```在上面的示例中，我们创建了一个名为Person 的类，其中包含两个受保护的成员变量（name 和age），以及两个受保护的方法（setName 和setAge）。

这意味着其他类只能通过Person 类的公共方法（如getName 和getAge）访问这些受保护成员。

3.保护关键字的作用保护关键字的主要作用是限制其他类对方法的访问，从而实现数据隐藏和封装。

通过使用保护关键字，我们可以确保其他类无法直接访问类的私有成员，只能通过公共方法访问。

这有助于提高代码的安全性和可维护性。

总之，在Java 中，保护关键字是一种访问控制修饰符，用于限制对类成员的访问。

java中import的用法在Java语言中，import是一个重要的关键字，它可以帮助程序员更加方便地使用另一个Java包里面的类或接口。

Import关键字用于导入某个Java包里面的类或接口，以便可以在程序中使用它们。

因此，在Java中使用import是很有必要的，尤其是当一个程序引用某个Java包里面的类或接口时。

import的语法格式如下所示：import名.*； import名.类名；第一个用法import名.*表示加载该包下的所有类，第二个用法import名.类名表示只加载该类，而其他类不加载。

这里要注意，import关键字必须写在类的第一行，即在其他指令之前，并且不能写在任何方法内部。

另外，在同一个类中引用多个类时，只需要写一次import，并以逗号分隔。

使用import关键字的优势：1、可以简化程序代码：使用import关键字可以使程序简洁而不必重复引用类。

2、可以明确指出哪个包的类被使用：使用import关键字可以在程序中指定哪些类或接口是被使用的，避免出现类的名字冲突的情况。

3、可以减少程序的代码量：使用import关键字可以有效地减少程序的代码量，提高程序的运行效率。

Java类库中的类比较多，且不断增长，因此在使用import关键字时，有时也会出现语法问题，这就需要程序员有一定的把握，要注意引入的import关键字应该放在程序的什么位置，这样才能保证import语句正确有效地执行。

此外，在实际的程序开发过程中，如果有用到某个类，就要加上相应的import语句，以便保证程序的正常运行。

因此，可以总结出，import关键字的使用可以使程序更加简洁，减少代码量，使程序更易于理解和维护，可以有效地提高程序的运行效率。

但在使用import关键字时，一定要仔细确认被引入的类，并正确放置import关键字，以保证程序的正常运行。

throw在java中的用法在Java编程语言中，throw关键字用于手动抛出异常。

它通常与try-catch语句一起使用，以在代码块中抛出自定义异常或处理已定义的异常。

使用throw关键字可以在程序执行过程中，某些特定的条件发生时主动抛出异常。

这有助于改善程序的可读性和可维护性，同时也可以提供更好的错误处理机制。

具体用法如下所示：1. 抛出已定义的异常：可以使用throw关键字抛出Java中已经定义好的异常类，例如NullPointerException、IllegalArgumentException等。

例如：```javathrow new NullPointerException("空指针异常");```2. 抛出自定义异常：除了抛出系统定义的异常，还可以通过自定义异常类来使用throw关键字抛出异常。

这样可以根据特定的需求定义自己的异常类型，并在程序中使用。

例如： ```javaclass MyException extends Exception {public MyException(String message) {super(message);}}throw new MyException("自定义异常");```3. 与try-catch语句一起使用：通常，在使用throw关键字时，需要将其放置在try块中，以便能够在catch 块或者上层调用栈中捕获并处理异常。

例如：```javatry {throw new Exception("异常信息");} catch (Exception e) {System.out.println("捕获到异常：" + e.getMessage());}```在使用throw关键字时，需要注意以下几点：- throw关键字只能抛出异常对象，不能抛出基本类型或者null。

java中super的用法一、super关键字的概述在Java编程语言中，super关键字常用于子类中，用于引用父类的成员变量、方法和构造方法。

通过使用super关键字，子类可以直接访问并调用父类中被隐藏或重写的成员。

二、使用super关键字访问父类的成员变量和方法2.1 访问父类的成员变量子类继承了父类的所有非私有成员变量，在子类中可以直接访问继承而来的这些成员变量。

如果子类中定义了与父类同名的成员变量，则可以通过使用super关键字来区分并访问父类中的成员变量。

例如，下面是一个简单的示例代码：```javaclass Parent {int num = 10;}class Child extends Parent {int num = 20;void display() {System.out.println("Child num: " + num);System.out.println("Parent num: " + super.num);}}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}}```输出结果为：```Child num: 20Parent num: 10```可以看到，Child类中定义了一个与Parent同名的成员变量num，并且在display()方法中通过super.num来访问父类中的num变量。

2.2 调用父类的普通方法与访问父类的成员变量类似，子类可以使用super关键字来调用父类中的普通方法。

在子类中重写了父类的方法后，想要调用父类的方法可以使用super关键字。

例如，下面是一个简单的示例代码：```javaclass Parent {void display() {System.out.println("Parent display() called"); }}class Child extends Parent {@Overridevoid display() {super.display(); // 调用父类的display()方法 System.out.println("Child display() called"); }}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}}```输出结果为：```Parent display() calledChild display() called```可以看到，在Child类中通过super.display()来调用父类中的display()方法。

Java关键字(keyword)和保留字(reserved word)的用法在java中有48个关键字和2个保留字。

经过学习，借助了谷歌的力量我将这些关键字和保留字整理如下。

一．访问限定。

1.public关键字: public的意思是公有的，public作为关键字可以放在类前，表示这个类可以被其他包中的类的对象所访问。

Public限定的类在文件中只允许有一个，且类名必须与文件名相同。

如果public用来修饰方法，表示方法可以被其他包中的类调用。

如果public用来修饰属性，则可直接通过对象名.属性来访问对象的属性。

2.private关键字: private的意思是私有的，其可调用性范围最小。

在方法的前面加上private，则方法只能由内部的方法或者构造器调用，通常，属性都是用private限定的，而一般的类前，都不加private限定。

在类继承时，父类中的private方法将不能被子类继承。

当我们给某个构造器加上private修饰符时，则不能创建某个类的对象。

3.protected关键字：protected限定符界于public和private之间。

被protected限定的方法，子类可以继承，在同一个包内可以访问，在不同的包内不可以访问。

这些关键字的用法如上所述，但为了更好的理解一些细节的问题，大家可以看一下我对下面这些问题的总结。

那么，一个类中是否可以定义两个或者两个以上的public类？我们可以在eclipse 中运行一下，结果如下：由上可见，在一个类中，Public限定的类在文件中只允许有一个，且类名必须与文件名相同。

若在类里面还要创建一个类的话，那就只能是默认的，不可以加其他访问修饰符，或者，可以在已有的类的内部，再创建一个类，但名字必须不同与文件名。

若属性使用public进行修饰，就可以直接通过对象·属性来访问对象的属性。

输出结果是name=向聘。

这里就是直接通过创建的对象来访问st对象的name属性的。

Java语言了弱同步机制，即volatile变量，以确保变量的更新通知其他线程。

volatile变量具备变量可见性、禁止重排序两种特性。

volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

volatile变量的两种特性：·变量可见性保证该变量对所有线程可见，这里的可见性指的当一个线程了变量的值，那么新的值对于其他线程可以立即获取的。

·禁止重排序volatile禁止了指令重排。

比sychronized更轻量级的同步锁。

在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量一种比sychronized关键字更轻量级的同步机制。

volatile适合这种场景：一个变量被多个线程共享，线程直接给这个变量赋值。

当对非volatile变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中。

如果计算机有多个CPU，每个线程可能在不同的CPU上被处理，这意味着每个线程可以拷贝到不同CPUcache中。

而声明变量volatile的，JVM保证了每次读变量都从内存中读，跳过CPUcache这一步。

适用场景值得说明的对volatile变量的单次读/写操作可以保证原子性的，如long和double类型变量，但并不能保证i++这种操作的原子性，因为本质上i++读、写两次操作。

在某些场景下可以代替Synchronized。

但，volatile的不能完全取代Synchronized的位置，只有在一些特殊的场景下，才能适用volatile。