private 和static的用法 - 360文档中心

Java中static关键字的作用和用法详细介绍

Java中static关键字的作⽤和⽤法详细介绍static表⽰“全局”或者“静态”的意思，⽤来修饰成员变量和成员⽅法，也可以形成静态static代码块，但是Java语⾔中没有全局变量的概念。

被static修饰的成员变量和成员⽅法独⽴于该类的任何对象。

也就是说，它不依赖类特定的实例，被类的所有实例共享。

只要这个类被加载，Java虚拟机就能根据类名在运⾏时数据区的⽅法区内定找到他们。

因此，static对象可以在它的任何对象创建之前访问，⽆需引⽤任何对象。

⽤public修饰的static成员变量和成员⽅法本质是全局变量和全局⽅法，当声明它类的对象市，不⽣成static变量的副本，⽽是类的所有实例共享同⼀个static变量。

static变量前可以有private修饰，表⽰这个变量可以在类的静态代码块中，或者类的其他静态成员⽅法中使⽤（当然也可以在⾮静态成员⽅法中使⽤–废话），但是不能在其他类中通过类名来直接引⽤，这⼀点很重要。

实际上你需要搞明⽩，private是访问权限限定，static表⽰不要实例化就可以使⽤，这样就容易理解多了。

static前⾯加上其它访问权限关键字的效果也以此类推。

static修饰的成员变量和成员⽅法习惯上称为静态变量和静态⽅法，可以直接通过类名来访问，访问语法为：类名.静态⽅法名(参数列表…)类名.静态变量名⽤static修饰的代码块表⽰静态代码块，当Java虚拟机（JVM）加载类时，就会执⾏该代码块（⽤处⾮常⼤，呵呵）。

1、static变量按照是否静态的对类成员变量进⾏分类可分两种：⼀种是被static修饰的变量，叫静态变量或类变量；另⼀种是没有被static修饰的变量，叫实例变量。

两者的区别是：对于静态变量在内存中只有⼀个拷贝（节省内存），JVM只为静态分配⼀次内存，在加载类的过程中完成静态变量的内存分配，可⽤类名直接访问（⽅便），当然也可以通过对象来访问（但是这是不推荐的）。

private的用法

private的用法
private的用法：
1.常用于描述一些私人的事物，例如私人生活。

私人生活包括自己的家庭、朋友、娱乐活动等，是一个人能够自由放松和享受的领域。

2.用于描述私人财产。

私人财产指的是个人所有的财产，包括不动产、动产以及金融资产。

3.与私人权利相关。

私人权利是指个人享有的一定权利和自由，包括人身自由、人格权、私密权、通讯自由等。

4.与私人信息相关。

私人信息指的是个人的姓名、地址、电话号码等个人信息。

5.与私人管辖权相关。

私人管辖权是指个人对自己生活和权益的管理权。

static用法

static用法
static 是 C 语言和 C++ 语言中的一种修饰符，用它修饰的变量或者函数就具有一定的特性，它有以下几种用法：
1. static 修饰全局变量：全局变量被声明为 static 类型后，就只能在声明它的文件里使用，其它文件里不能使用它。

2. static 修饰局部变量：在函数体内，声明变量为 static 类型的话，就变成了静态变量，其值会一直保存，直到程序结束才会释放，但是它的作用域(可以访问的范围)仍然为定义它的函数内部。

3. static 修饰函数：函数被声明为静态的意思是它仅能在本文件中被调用，函数被声明为静态，可以节省空间，不会放入到全局表中去。

4. static 修饰类成员：声明类成员变量为 static 类型，意味着每一个该类对象都会共用一个公共的变量。

总而言之，static 可以将变量和函数的作用域范围限定在声明它们的文件中，减少各个文件之间的调用，使程序更有效率。

static 用法

static 用法static 用法1. static 变量•定义：在函数内部使用 static 关键字声明的变量称为静态变量。

•特点：–静态变量的生命周期在整个程序运行期间都存在，而不仅仅在函数调用时才存在。

–静态变量存储在静态存储区，不会在函数调用结束后释放内存。

•使用场景：–如果一个变量需要在多次函数调用之间保持其值不变，可以使用静态变量。

–静态变量通常用于计数器或者保存函数的返回值等场景。

•示例代码：#include <>int count() {static int counter = 0;counter++;return counter;}int main() {printf("%d\n", count()); // 输出1printf("%d\n", count()); // 输出2printf("%d\n", count()); // 输出3return 0;}2. static 函数•定义：在函数返回类型前面加上 static 关键字，使函数变为静态函数。

•特点：–静态函数只能在声明它的源文件内部调用，不能被其他源文件使用。

–静态函数不能被其他源文件中的函数调用，从而起到了隐藏的作用。

•使用场景：–当某个函数只在当前源文件内部使用时，可以将其声明为静态函数，以减少命名冲突和提高代码的模块化程度。

•示例代码：#include <>static int multiply(int a, int b) {return a * b;}int main() {int result = multiply(2, 3);printf("%d\n", result); // 输出6return 0;}3. static 类成员•定义：在类中声明的 static 成员属于类本身，而不是类的实例。

•特点：–所有的对象共享同一个静态成员，即静态成员对于所有的对象来说只有一份拷贝。

private动词用法

“private”是一个形容词，而不是一个动词。

它的基本意思是“私人的”、“私密的”或“私有的”。

以下是“private”的一些常见用法：
1. 作为形容词，修饰名词：
* a private conversation（私人对话）
* a private email（私人电子邮件）
* a private moment（私密时刻）
2. 后面接介词“with”表示“与某人私下”：
* I had a private conversation with her.（我与她进行了私下谈话。

）
3. 组成词组“in private”：
* Can we talk in private?（我们能私下谈谈吗？）
4. 用作名词：表示“私立学校”：
* My children attend a private school.（我的孩子上的是一所私立学校。

）
5. 用作动词：在某些情况下，“private”也可以用作动词，表示“把某物或某人与公众隔离”或“隐藏某物或某人不让他人知道”。

但这并不常见，而且在很多情况下，更好的选择是使用其他动词。

总的来说，“private”通常用作形容词，表示某事物或某人是私有的或私密的。

要表示其他意思，通常有更好的词汇选择。

java中作用域private的用法

java中作用域private的用法摘要：1.Java 中作用域private 的概念2.private 作用域的用法a.类的私有成员b.方法的私有成员c.静态私有成员3.private 作用域的限制4.实例：使用private 关键字正文：在Java 编程语言中，作用域（scope）是指变量或方法能够被访问和操作的范围。

private 是Java 中的一个访问修饰符，用于限制类、方法或变量的作用域。

当一个成员被声明为private 时，它只能在声明它的类内部访问，不能被其他类直接访问。

这有助于保护类的内部实现，防止外部不必要地修改或访问。

以下是private 作用域的用法：1.类的私有成员：当一个类变量被声明为private 时，它只能在声明它的类内部访问，不能被其他类直接访问。

例如：```javaclass Animal {private String name;public void setName(String name) { = name;}public String getName() {return name;}}```在这个例子中，Animal 类的name 变量是私有的，只能通过setName 和getName 方法来访问和修改。

2.方法的私有成员：当一个方法被声明为private 时，它只能在声明它的类内部访问，不能被其他类直接访问。

例如：```javaclass Animal {public void makeSound() {System.out.println("The animal makes a sound");}private void makeSoundPrivately() {System.out.println("The animal makes a private sound");}}```在这个例子中，Animal 类有两个makeSound 方法，其中makeSoundPrivately 是私有的，只能在Animal 类内部访问。

static的五种用法

static的五种用法
"static" 这个关键字在编程中有多种用法，具体用法取决于编程语言。

以下是"static" 关键字在许多编程语言中常见的五种用法：
1. 静态变量（Static Variables）：
在函数内部声明的静态变量在程序执行期间保持其值不变。

它们在函数调用之间保持其值，而不像普通的局部变量那样在每次函数调用时重新初始化。

2. 静态方法（Static Methods）：
在类中声明的静态方法是不需要实例化类就可以调用的方法。

它们通常用于执行与类相关的操作，而不是与实例相关的操作。

3. 静态类（Static Classes）：
在一些编程语言中，可以声明静态类，这些类不能被实例化，且只能包含静态成员。

4. 静态成员变量（Static Member Variables）：
在类中声明的静态成员变量是类的所有实例共享的变量。

它们的值对于所有实例都是相同的。

5. 静态导入（Static Imports）：
在Java 中，可以使用静态导入来直接访问静态成员，而不需要使用类名来限定。

这样可以简化代码，使得静态成员的使用更加方便。

需要注意的是，不同的编程语言可能会对"static" 关键字有不同的用法和语义。

上述用法主要是针对一些常见的编程语言，比如C/C++、Java、C# 等。

在特定的编程语言中，"static" 关键字可能还有其他用法。

private static void语句

文章标题：深入理解private static void语句在软件开发中，private static void语句是一个非常重要的概念。

它在面向对象的编程中起着至关重要的作用，影响着程序的结构和性能。

在本文中，我们将深入探讨private static void语句的含义、用途和原理，并共享个人的见解和理解。

1. private static void 的含义让我们来了解一下private static void语句的含义。

在Java等面向对象的编程语言中，private是一种访问修饰符，表示该成员只能在所属的类内部访问，不能被其他类直接访问。

static表示该方法或成员属于类级别，而不是实例级别，可以通过类名直接访问，无需创建对象。

而void表示该方法没有返回值。

private static void语句表示一个只能在所属类内部访问，属于类级别的方法，没有返回值。

2. private static void 的用途接下来，让我们来探讨private static void语句的用途。

通常情况下，private static void方法用于封装一些内部的逻辑，不希望被外部直接调用，同时又不需要返回数值。

一个工具类中的一些辅助方法就可以使用private static void来实现。

private static void方法也常用于实现一些初始化的逻辑，或者进行一些内部状态的管理，起到了将代码封装、模块化的作用。

3. private static void 的原理再来，我们来探讨private static void语句的原理。

在Java虚拟机中，private static void方法是以特定的字节码形式存在的。

在编译阶段，私有静态方法会被编译成普通的静态方法，只是在类的内部调用时需要用到额外的访问标识符。

这些方法的字节码会随着类的加载而加载到方法区中，可以被类的所有实例共享。

4. 个人观点和理解我想共享一下我对private static void语句的个人观点和理解。

java中static的用法

java中static的用法Java 中的 static 关键字在编程中非常常见，它可以用来修饰方法、变量和代码块。

下面将对这些用法做详细的介绍：1. 用来修饰变量在 Java 中，static 可以用来修饰变量，此时该变量被称为静态变量。

静态变量是所有对象共享的，而不是每个对象都有一份副本。

因此，如果在一个对象中修改了静态变量的值，那么其他对象中的该变量的值也会被修改。

以下是一个使用 static 定义静态变量的示例：```public class Example {static int count = 0;public Example() {count++;}}```在这个示例中，定义了一个静态变量 count，记录了实例化 Example 对象的次数。

2. 用来修饰方法在 Java 中，static 也可以用来修饰方法，此时该方法被称为静态方法。

静态方法不依赖于任何对象实例，而是直接在类上调用。

因此，静态方法不能直接访问非静态方法或变量。

以下是一个使用 static 定义静态方法的示例：```public class Example {public static int max(int[] arr) {int max = arr[0];for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}return max;}}```在这个示例中，定义了一个静态方法 max，用于返回一个整型数组中的最大值。

3. 用来修饰代码块在 Java 中，static 也可以用来修饰代码块，该代码块被称为静态代码块。

静态代码块只会在类加载时执行一次。

静态代码块通常用来初始化静态变量。

以下是一个使用 static 定义静态代码块的示例：```public class Example {static {System.out.println("静态代码块执行了！");}}```在这个示例中，定义了一个静态代码块，当 Example 类被加载时，会执行该静态代码块打印相应信息。

详谈PHP中public,private,protected,abstract等关键字的用法

详谈PHP中public,private,protected,abstract等关键字的⽤法PHP中常⽤的关键字在PHP中包含了很多对函数和类进⾏限制的关键字，常⽤的通常有abstract,final,interface，public，protected,private,static等等，下⾯我们就将对这些进⾏分析整理各个的⽤法。

变量与⽅法的关键字public,private,protectedpublic的权限最⼤，既可以让⼦类使⽤，也可以⽀持实例化之后的调⽤，protected表⽰的是受保护的，访问的权限是只有在⼦类和本类中才可以被访问到private 表⽰的是私有，只能够是在当前的类中可以被访问到<?php///*** Define MyClass*/class MyClass{public $public = 'Public';protected $protected = 'Protected';private $private = 'Private';public function printHello(){echo $this->public;echo $this->protected;echo $this->private;}protected function pro_test(){var_dump(1);}}$obj = new MyClass();echo $obj->public; // 这⾏能被正常执⾏//echo $obj->protected; // 这⾏会产⽣⼀个致命错误//echo $obj->private; // 这⾏也会产⽣⼀个致命错误$obj->printHello(); // 输出 Public、Protected 和 Private$obj->pro_test();//直接报错>变量与⽅法的关键字staticstatic的作⽤就是能够实现值或者⽅法在类中不需实例化的情况下调⽤，同时static修饰的变量具有与值存储的功能，例如我们不使⽤static运⾏的结果如下：<?phpfunction test(){$var=1;echo $var."</br>";$var++;}test();// 1test();// 1test();// 1>如果我们给变量加上static那么就会变成这样<?phpfunction test(){static $var=1;echo $var."</br>";$var++;}test();// 1test();// 2test();// 3这⾥可能不能够体会到PHP这样做的好处，那么我们就先来假设⼀下读者也熟悉JS，在JS中是没有static这个关键字的，所以如果我们要来实现⼀个具有能够保存每⼀次程序运算结果作为下⼀次运算的依据的⼀个程序我们需要这样来写。

c语言static 的三个作用

c语言static 的三个作用static是C语言中的关键字，常用于定义变量和函数。

它有三个主要的作用：作用域限定、生命周期延长和隐藏实现。

一、作用域限定：1.1局部变量的作用域限定：在函数内部使用static修饰的局部变量，使其只能在定义它的函数内部使用，不能被其他函数访问。

这样可以避免在不同函数中使用相同名称的变量造成的冲突。

1.2函数的作用域限定：在函数外部使用static修饰的函数，使其只能在本文件内部使用，不能被其他文件调用。

这主要用于隐藏一些辅助性的函数，提高程序的安全性和模块化程度。

二、生命周期延长：2.1局部变量的生命周期延长：使用static修饰的局部变量，在程序运行时一直存在，不会随着函数执行结束而销毁，直到程序结束才会被销毁。

这样可以在多次调用函数时保持变量的值不变，起到记忆的作用。

2.2全局变量的生命周期延长：使用static修饰的全局变量，生命周期同样延长到整个程序运行期间。

这样可以在不同的函数中共享同一个全局变量，达到数据共享的目的。

三、隐藏实现：使用static修饰的变量和函数，其作用域被限定在本文件内部，其他文件无法直接使用和访问，从而隐藏了其具体的实现细节。

这样可以提高程序的安全性和可维护性，使得代码更加模块化。

下面进一步解释每个作用：1.作用域限定：1.1局部变量的作用域限定在函数内部使用static修饰局部变量，该变量只能在定义它的函数内部使用，无法在其他函数中使用。

这种限制避免了在不同的函数中多次声明相同名称的变量带来的冲突。

同时，static修饰的局部变量在函数执行完毕后并不销毁，而是保留其值，下次再次调用该函数时，仍能使用先前存储的值。

比如：```cvoid func() {static int count = 0;count++;printf("%d\n", count);}```在上面的例子中，count是一个静态局部变量，每次调用func函数时，count的值会自增并输出。

class修饰符public、private、protected、static、abstract

class修饰符public、private、protected、static、abstract class修饰符的使⽤及区别public、private、protected、static、abstractpublic：可以继承、实例化class Person {public name: string;constructor(thename: string) { = thename;}}class Jack extends Person {age: number;constructor(name: string, age: number) {super(name)this.age = age;}say() {console.log(`my name is ${}, age ${this.age}`);}}let p1 = new Person('tom');console.log(); // tomlet j1 = new Jack('jacker', 10);j1.say(); // my name is jacker age 10 private 私有属性只能在基类中访问，不能在实例、派⽣类中访问class Person {private name: string;constructor(thename: string) { = thename;}sayname() {console.log(`my name is ${}`);}}class Jack extends Person {age: number;constructor(name: string, age: number) {super(name)this.age = age;}say() {// 只能在Person中访问// console.log(`my name is ${}, age ${this.age}`); // error}}let p1 = new Person('tom');p1.sayname(); // tom// console.log(); // tom // error 只能在Person中访问let j1 = new Jack('jacker', 10);j1.sayname(); // jacker protected 受保护的，可以被继承，在派⽣类中可以访问，⼦类、⽗类都不能实例访问class Person {protected name: string;constructor(thename: string) { = thename;}sayname() {console.log(`my name is ${}`);}}class Jack extends Person {constructor(name: string) {super(name)}say() {// 只能在Person中访问console.log(`my name is ${}`);}}let p1 = new Person('tom');p1.sayname(); // tomconsole.log(); // tom // error 只能在Person、⼦类中访问let j1 = new Jack('jacker');j1.say(); // jackerconsole.log(); // error 只能在Person、⼦类中访问 // static 只能通过基类、⼦类访问，实例不能访问class Person {static myName: string;constructor(name: string) {Person.myName = name;}sayname() {return Person.myName;}}class Jack extends Person {constructor() {super('jacker');}}let p1 = new Person('tom');p1.myName; // error Person上不存在myName属性console.log(p1.sayname());// tom// 在类的外部访问console.log(Person.myName); // tomlet j1 = new Jack();// ⼦类实例访问基类⽅法console.log(j1.sayname()); // jackerj1.myName // error Jack 上不存在myName属性// ⼦类访问静态属性console.log(Jack.myName); // jacker // abstract 抽象类中的抽象⽅法不包含具体实现并且必须在派⽣类中实现abstract class Person {sayname() {console.log('my name is sayname');}// 抽象⽅法不具体实现abstract say(): void;}class Jack extends Person {// ⼦类必须实现⽗类抽象⽅法say() {console.log('my name is jacker');}}// let p1 = new Person(); // 抽象类不可以被实例化let j1 = new Jack();j1.sayname();j1.say()class修饰符的使⽤及区别public、private、protected、static、abstractpublic：可以继承、实例化// public可以继承、实例化class Person {public name: string;constructor(thename: string) { = thename;}}class Jack extends Person {age: number;constructor(name: string, age: number) {super(name)this.age = age;}say() {console.log(`my name is ${}, age ${this.age}`);}}let p1 = new Person('tom');console.log(); // tomlet j1 = new Jack('jacker', 10);j1.say(); // my name is jacker age 10private 私有属性只能在基类中访问，不能在实例、派⽣类中访问class Person {private name: string;constructor(thename: string) { = thename;}sayname() {console.log(`my name is ${}`);}}class Jack extends Person {age: number;constructor(name: string, age: number) {super(name)this.age = age;}say() {// 只能在Person中访问// console.log(`my name is ${}, age ${this.age}`); // error}}let p1 = new Person('tom');p1.sayname(); // tom// console.log(); // tom // error 只能在Person中访问let j1 = new Jack('jacker', 10);j1.sayname(); // jackerprotected 受保护的，可以被继承，在派⽣类中可以访问，⼦类、⽗类都不能实例访问class Person {protected name: string;constructor(thename: string) { = thename;}sayname() {console.log(`my name is ${}`);}}class Jack extends Person {constructor(name: string) {super(name)}// 只能在Person 中访问console .log(`my name is ${this .name}`);}}let p1 = new Person('tom');p1.sayname(); // tomconsole .log(); // tom // error 只能在Person 、⼦类中访问let j1 = new Jack('jacker');j1.say(); // jacker console .log(); // error 只能在Person 、⼦类中访问say() {class Person {static myName: string;constructor (name: string) {Person.myName = name;}sayname() {return Person.myName;}}class Jack extends Person {constructor () {super ('jacker');}}let p1 = new Person('tom');p1.myName; // error Person 上不存在myName 属性console .log(p1.sayname());// tom// 在类的外部访问console .log(Person.myName); // tomlet j1 = new Jack();// ⼦类实例访问基类⽅法console .log(j1.sayname()); // jackerj1.myName // error Jack 上不存在myName 属性// ⼦类访问静态属性 console .log(Jack.myName); // jackerabstract class Person {sayname() {console .log('my name is sayname');}// 抽象⽅法不具体实现abstract say(): void ;}class Jack extends Person {// ⼦类必须实现⽗类抽象⽅法say() {console .log('my name is jacker');}}// let p1 = new Person(); // 抽象类不可以被实例化let j1 = new Jack(); j1.sayname(); j1.say();// static 只能通过基类、⼦类访问，实例不能访问// abstract 抽象类中的抽象⽅法不包含具体实现并且必须在派⽣类中实现。

java中private的用法

java中private的用法
private 是Java 中比较常见的变量修饰符.
private 指定的变量或者方法只能在拥有它的类内进行访问.更精确地说,只能从
它所属的类的类内方法,基类或者内部类访问.除此以外的类是不能访问的.
也就是说, private 定义的变量和方法只在当前类内可见, 其他外部类不可见. 这
样有利于Java应用的稳定性和可安全性的提升.
private 最重要的机制应用就是保护应用不易受外部破坏,尤其是数据层面的安
全性. Java 的类可以设置为只有特定几个可以介入访问此类, 这些被允许访问此类
的调用者通常称为友好类.
另一方面, private 同样可以避免在类外部不必要的滥用. 因为类外部没有能力访问, 就不存在非法使用类内部方法和变量的情况. 这样有助于保持内部程序正常运转.
因此，private 是Java 中非常重要的变量修饰符，它通过限定准入的访问权限，并 hidden 内部方法和变量，有效保护应用安全及稳定，提升应用的可靠性及健壮性。

private的用法和搭配

private的用法和搭配【最新版】目录1.介绍 private 的含义和用途2.讲述 private 的用法3.讨论 private 的搭配4.总结 private 的使用注意事项正文【private 的含义和用途】在编程语言中，private 是一个访问修饰符，用于限制类的成员变量或方法的访问权限。

它的主要用途是保护类的内部实现细节，防止外部直接访问和操作，从而实现数据和方法的封装。

【private 的用法】private 的用法非常简单，只需在成员变量或方法的前面添加private 关键字即可。

在 Python 等面向对象编程语言中，还可以使用双下划线（__）作为 private 的替代。

下面是一个使用 private 的示例：```pythonclass Person:private_name = "张三"def private_method(self):print("这是私有方法")p = Person()print(p.private_name) # 这里会报错，因为 private_name 是私有的p.private_method() # 这里也会报错，因为 private_method 是私有的```【private 的搭配】private 通常与访问修饰符 public 和 protected 一起使用，它们共同构成了访问控制机制。

下面是一些关于 private 的搭配示例：- public：公共的，可以被任何类或对象访问。

- protected：受保护的，可以被同一包中的其他类或子类访问。

- private：私有的，只能被本类中的方法访问，不能被其他类或对象访问。

这种搭配可以有效地控制类的成员变量和方法的访问范围，从而提高代码的安全性和可维护性。

【总结】在使用 private 时，需要注意以下几点：1.尽量将类的实现细节设为 private，以实现封装。

Java关键字(keyword)和保留字(reserved word)的用法

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属性的。

private和static的用法

private和static的用法
private（私有）说明只有在本类内被调用外部人使用它必须用getset方法来获取,不能直接使用.
static 说明是静态的对象，可以直接用（类名.对象）来调用。

static:加static 的是静态成员,不能实例化在你运行的时候他自己在内存中开辟了块空间,不用在new, 有点像全局变量,如果不用你必须去实例化(new)才能用
static是静态的意思，public或private与其他成员一样
1、访问static成员，只能用类而不是实例化的对象；
2、static方法只能访问static属性；
3、static成员可以保留其值
private static 和 public static 都是静态变量,在类加载时就定义,不需要创建对象
但是private static 是私有的,不能在外部访问,只能通过静态方法调用,这样可以防止对变量的修改。

引用static类型的方法

引用static类型的方法static类型方法是属于类的方法，不属于一些具体的对象。

可以直接通过类名来调用，无需创建实例。

在Java中，static类型的方法在很多场景下都非常有用，比如工具类的方法、数学计算函数等等。

接下来，我会通过讲解一些具体的应用场景，来展示static类型方法的用途。

第一个应用场景是工具类的方法。

通常在开发中，我们会编写一些工具类，其中包含了一些与业务逻辑无关的通用功能。

这些功能可以通过static类型的方法来实现，让开发者无需每次都创建实例，直接通过类名调用即可。

比如，我们可以创建一个StringUtil工具类，其中包含了一些字符串处理的静态方法，如判断字符串是否为空、将字符串格式化为指定长度等等。

第二个应用场景是数学计算函数。

Java提供了一些与数学相关的类，例如Math类，其中包含了一些常用的数学计算方法，比如sin、cos、sqrt等等。

这些方法都是被声明为static类型的，因为它们不需要与具体的对象关联，而是直接通过类名调用即可。

这样的设计可以提高代码的简洁性和可读性，同时也方便了开发者使用。

除了工具类和数学计算函数外，还有一些其他的场景也可以使用static类型方法。

例如，单例模式中的getInstance方法通常也会被声明为static类型的，用于获取唯一的实例对象。

在多线程环境下，使用static类型方法可以减少线程安全问题的出现。

此外，在实现一些设计模式时，比如工厂方法、策略模式等等，static类型方法也能提供更好的实现方式。

虽然static类型方法有很多优点，但也需要注意一些限制。

首先，由于static类型方法不与具体的对象关联，所以无法直接访问非static 成员，包括非static成员变量和非static方法。

其次，static类型方法是类级别的，而非实例级别的，所以无法直接访问this关键字，也无法在方法体中使用super关键字。

最后，static类型方法不能被重写，因为它们属于类级别的方法。

static的用法

static的⽤法static，意为静态的，是⼀个状态修饰符。

1.修饰变量static修饰的变量称为静态变量，可以使⽤类名.变量名直接调⽤，并且该变量只存在⼀份，被所有的实例共享。

（1）类名.变量名调⽤静态变量：例：package com.dh.oop;public class StaticField {public static int num = 1;}package com.dh.oop;public class StaticFieldApplication {public static void main(String[] args) {//类名调⽤System.out.println(StaticField.num);}}（2）静态变量只存在⼀份，被所有的实例共享：例：package com.dh.oop;public class StaticField {public static int num = 1;}package com.dh.oop;public class StaticFieldApplication {public static void main(String[] args) {//实例化两个变量，并分别为num赋值StaticField staticField1 = new StaticField();staticField1.num = 2;StaticField staticField2 = new StaticField();staticField2.num = 3;System.out.println(staticField1.num);System.out.println(staticField2.num);}}通过以上代码，若所有实例共享⼀份静态变量的话，输出的值应该都为3，否则，为2，3可以看到，结果为两个3，由此可证，所有实例共享⼀份静态变量。

2.修饰⽅法被static修饰的⽅法称为静态⽅法。