华清远见重庆中心—后端面向对象阶段个人总结

NotFoundThisPerson

已于 2023-03-27 00:02:34 修改

阅读量140

点赞数

文章标签： jvm

于 2023-03-12 23:23:08 首次发布

本文链接：https://blog.csdn.net/G6543987/article/details/129389381

版权

Java中标识符的命名规则

标识符

类名、方法名、变量名统称为标识符

标识符命名规范

帕斯卡命名法：所有单词首字母大写

如StudentInfomation、Employee、ClassName

驼峰命名法：第一个单词首字母小写，其余单词首字母大写

如studentInfomation 、 employee 、 className

类名使用帕斯卡命名法

方法名、变量名使用驼峰命名法

变量命名的要求

使用字母、数字、下划线或$符号组成

不能使用数字开头

不能使用关键字

见名知意

方法

方法是定义在类中的一段独立代码，能完成某个事情。

定义方法时，提供 方法的名称、返回值类型、参数列表 ，这三点称为方法三要素，定义的方法都需要这三部分。

当再使用该方法中的代码时，只需通过该方法名调用即可。

方法能够减少代码冗余。

调用方法

1.通过类名调用

Math类

Math 类是 Java 中的工具类，用于数学计算。

该类中的方法和属性都使用 static 修饰的，可以 直接通过类名 调用。

在任何类中，通过快捷键 alt+7 ，展示方法列表

2.通过对象调用

创建对象: 类名对象名 = new 类名([参数]);

Scanner sc = new Scanner(System.in);
sc.方法名（）；

Random rd  = new Ranner();
rd.方法名（）;

3.在同一个类中，方法A直接调用方法B

class Test{

    void funA){
        funB();
    }


void funB(){
System. out. print1n("我是B方法");
    }
}

4.方法调用总结

调用方式

1.通过类名调用

2.通过对象调用

3.直接调用

参数

有参数

Scanner sc = new Scanner(System.in);
sc.next();//调用无参数方法

无参数

Random rd = new Random();
rd.nextInt(10);//调用有参数方法

返回值

没有返回值，方法名的前面用void表示

class Test{
    void funB(){
        System.out.println("我是B方法");
}
public static void main(String[] args){
        Test t = new Test();
        t.funB();
    }
}

有返回值

Random rd = new Random();
int num=rd.nextInt(10);

自定义方法

方法的三要素：

1、方法名：使用驼峰命名法

2、方法返回值类型

如果有返回值，使用 Java 中的任意数据类型，方法体中使用 return 关键字返回对应类型的数

据，如果没有返回值，使用void 关键字

3、方法参数列表

参数写法：数据类型形参名 , 数据类型形参名

方法的类型

无参数无返回值

int 方法名(){
    return new Random().nextInt();
}

无参数有返回值

int 方法名(){
    return new Random().nextInt();
}

有参数无返回值

void 方法名(数据类型 形参名,数据类型 形参名){
    //方法体
    return;
}

有参数有返回值

//生成a,b中包含最小值，不包含最大值范围内的随机数
double rand(int a,int b){
    double num=Math.floor(Math.random()*Math.abs(a-b)+Math.min(a,b));
    return num;
}

注意

1、有返回值的方法，必须要在方法体中加入 return 并能够执行，同时要 return 一个该方法返回值类型对应的数据。

2、没有返回值的方法，可以不用加入 return 关键字。如果加入 return 关键字，不能跟上数据。

3、方法中出现 return ，会立即结束方法。所以 return 语句之后不能再有代码。

4、定义方法时的参数称为形式参数，简称形参 ; 调用方法时，实际传递的参数称为实际参数，简称实参。实参只需保证数据类型和形参相同即可。

类和对象

类Class

具有相同属性和行为的对象的集合。 相当于模板。

属性：描述这个类的特征值，在程序中，通过定义变量 实现。

行为：描述这个类的动作，在程序中，通过定义方法 实现。

创建一个 class 文件，就是创建一个类。

定义类

[修饰符 ] class 类名{

//属性 ( 定义变量)

//行为 ( 定义方法)

}

/*
* 定义车的模板
* 属性：变量
* 品牌
* 颜色
* 座位数
* 排量
* ...

*
* 行为：方法
* 跑
* 说话
* 飞
*
* */
public class Car {
    //定义变量 数据类型 变量名 ;
        String brand;
        String color;
        int seat;

//定义方法
void run(){
    System.out.println("车在跑。。。");
}
void introduce(){
        //在方法中可以直接访问同一个类中的属性
        System.out.println("我是一辆"+brand+"牌的"+color+"色的"+seat+"座车");
    }
}

对象Object

对象由某个类创建出来的具体实例。

创建对象

类名对象名 = new 构造方法 ([ 参数 ]);

创建出的对象，通过 "." 操作符访问类中的非私有属性和方法。

public class Test4 {
    public static void main(String[] args) {
    // 创建Car类的对象
    //类名 对象名 = new 类名();
    Car benz = new Car();
    //对象.类中的属性和方法
    benz.seat = 5;
    benz.color="白";
    benz.brand="奔驰";
    benz.introduce();
    benz.run();
    }
}

类和对象的关系

对象是类的具体表现，类是对象的模板。

如制作月饼的模具就是一个类，每次用这个模具创建出来的月饼就是一个对象。

先定义类，才能通过该类获取对象。

成员变量和局部变量

成员变量

定义在类中的变量，称为成员变量，有默认值。

数据类型	默认值
整型	0
浮点型	0.0
布尔型	false
引用类型(类、数组、接口)	null

class Person{
    String name;//成员变量,String是类类型，属于引用类型，默认为null
    int age;//整型，默认0
    double[] list;
    void fun(){
        System.out.println(name);//这里能通过编译，可以使用name，输出null
        System.out.println(list[0]);//这里能通过编译，由于list为null，会报空指针异常
    }
}

局部变量

定义在方法中的变量，称为局部变量。没有默认值，赋值后才能使用。

成员变量和局部变量相关面试题

简述成员变量和局部变量的区别以及生命周期

成员变量是定义在类中的变量，有默认值，不赋值也能使用

局部变量是定义在方法中的变量，没有默认值，需要赋值后才能使用

成员变量的生命周期：类创建对象，成员变量就会初始化；类的对象被回收，成员变量就会销

毁

局部变量的生命周期：方法调用，对局部变量赋值，局部变量初始化，方法调用结束，局部变

量失效。

构造方法

概念

构造方法也称为构造函数、构造器、 constructor

它是一个特殊的方法。

没有返回值部分，方法名和类名一致，在创建对象时通过 new 调用，给类的成员变量赋值。

class Person{
//成员变量
String name;
int age;
//这就是一个无参数的构造方法，用于new Person()
Person(){
}
//这就是一个带参数的构造方法，用于new Person("admin",20)
Person(String name,int age){
this.name=name;//将参数的值赋值给成员变量
this.age=age;
}
}

特点

创建对象时必须通过 new 配合构造方法

构造方法没有返回值部分，名称和类名相同

构造方法可以存在多个，但是参数不能相同。这些构造方法之间的关系称为方法重载

每个类默认有一个隐藏的无参数的构造方法，方法体中隐含了一句 super() 。用于创建无参数的对象

如果自己写了带参数的构造方法，默认无参数的构造方法就会失效。如果想要同时拥有带参数和不

带参数的构造方法，

就需要再次显式地写出来

带参数的构造方法常用于初始化成员变量 ( 给类中的变量赋值 )

构造方法可以限制创建对象时携带的参数

构造方法无法通过 "." 操作符访问，只能通过 new 关键字创建对象时调用

IDEA中自动生成构造方法

在类空白处右键 generate 或快捷键 alt+insert

在弹出的窗口中，选择 Constructor

选择生成的构造方法的参数，全选ctrl+a

面向对象语言的三大特性--封装

封装

使用 private 关键字对成员变量进行修饰。再提供一组 get 和 set 的方法，用于对该属性读取和赋值。

可以防止除自身类之外的地方对 private 修饰的属性进行访问。

这样就能保护关键属性或给属性赋一个合理的值。

步骤

1. 创建类，编写成员变量，对成员变量使用 private 修饰

class Person{
private String name;
private int age;
}

2. 给所有成员变量添加 set 方法，用于赋值

void setName(String name){
this.name=name;
}
void setAge(int age){
this.age=age;
}

3. 给所有成员变量添加 get 方法，用于读取

String getName(){
return name;
}
int getAge(){
return age;
}

创建该类对象后，无法直接通过 . 访问属性，只能通过 get/set 读取和赋值

public static void main(String[] args){
Person p = new Person();
//p.name;//无法通过.访问被private修饰的属性
p.setName("王海");
String name = p.getName();
}

IDEA中自动生成getter/setter方法

在类中空白处右键 generate 或快捷键 alt + insert ，在弹出的窗口中选择 getter and setter

在弹出的窗口中，选择要生成get和set方法的成员变量

IDEA中自动使用变量接收对象

在对象后 .var 或快捷键 ctrl+alt+v

public static void main(String[] args) {
//创建对象自动使用变量保存 ctrl + alt + v 或 对象.var
Employee employee = new Employee();
}

面向对象三大特性--继承

概念

类 B 使用 extends ( 延伸 ) 关键字 " 继承 " 类 A 。

语法： class 类 B extends 类 A {}

类 B 称为类 A 的子类，衍生类， subClass

类 A 称为类 B 的父类，超类、 supClass

继承后，子类就能访问父类中的非私有 ( 没有使用 private 修饰 ) 成员变量和成员方法。

class A{
private String secret="父类中的私有属性";
String name="父类";
void info(){
System.out.println("父类中的非私有方法");
}
}
class B extends A{
void fun(){
System.out.println(secret);//无法访问父类中的私有成员变量
System.out.println(name);//可以访问非私有成员变量
info();//可以直接调用父类中的非私有方法
}
}

将多个类中的公共代码提取出来保存到一个公共类中，这些类使用 extends" 继承 " 这一个公共类，从而减

少这些类中的冗余代码。

如猫类、狗类都有类型、昵称等属性，也有吃、睡等方法，那就可以定义一个动物类，将这些公共的属

性和方法定义在动物类这个父类中，

再让猫类和狗类这些子类继承动物类。这样就能直接通过子类访问父类中的内容。

特点

如果多个类之中有相同的代码，可以将这些代码提取出来到一个公共的类中，这个类就是父类。再

让那些类去 extends 继承这个父类，那些类就是子类。子类就无需再写重复代码

子类中或子类对象可以直接访问父类中非私有 ( 不用 private 修饰 ) 属性和方法

创建子类对象时，会先执行父类中相应的构造方法

子类继承父类后，通常会对对父类中的方法进行拓展或覆盖，这称为方法重写。重写后，子类再调

用该方法时，执行的是重写后的内容

Java 中是单继承。一个子类只能 extends 一个父类，一个父类可以有很多子类

Java 中可以多重继承，类 A 可以继承类 B ，类 B 继承类 C ，这是类 A 既是类 B 的子类，也是类 C 的子

类，类 A 可以访问类 B 和类 C 中的非私有成员

任何类都是 Object 类的子类

方法重写和方法重载

方法重写override

当子类继承父类后，可以对父类中的方法进行扩展或覆盖。这个过程称为方法重写。

方法重写要求

方法名、返回值、参数列表必须和父类一致

访问权限不能比父类更严格 ( 访问修饰符的范围要么一致要么更大 )

不能抛出比父类更大的异常

IDEA 中如果要重写方法，使用 CTRL + O 在弹出的窗口中选择要重写的方法

方法重载overload

在一个类中，如果多个方法的方法名相同，参数列表不同时，这些方法称为重载的方法。

同名不同参 。

重载用于，在一个类中，某个方法在不同的条件下，执行不同的内容。

方法重载要求

方法名相同

参数必须不同 ( 数量、类型 )

与返回值无关

重载和重写相关面试题

说出重载与重写的异同

相同点：方法名不变

不同点：

重载在一个类中，重写在继承关系中子类重写父类

重载参数必须不同，重写参数必须相同

重载返回值无要求，重写返回值必须相同

构造方法能重载吗？能重写吗？

构造方法可以重载。构造方法不能重写。

构造方法在执行时，一定会创建对象吗 ?

不一定。创建子类时会自动执行父类构造方法，但不会创建父类对象。

以下代码执行会输出什么结果

class Father(){
Father(){
fun();
}
void fun(){
System.out.println("父类中的普通方法");
}
}
class Son extends Father{
Son(){
fun();
}
void fun(){
System.out.println("子类中的普通方法");
}
}
class Test{
public static void main(String[] args){
//1.创建父类对象，调用父类中无参构造方法
//2.无参构造方法中调用fun()，调用父类中的方法，输出“父类中的普通方法”
new Father();//父类中的普通方法
//1.创建子类对象，先调用父类中无参构造方法
//2.无参构造方法中调用fun(),由于fun()子类对其进行了重写，调用的是重写后的方法，
输出"子类中的普通方法"
//3.执行子类中无参构造方法，调用重写后的fun(),输出“子类中的普通方法”
new Son();//"子类中的普通方法"打印两次
}
}
//最终输出
//父类中的普通方法
//子类中的普通方法
//子类中的普通方法

this和super关键字

这两个关键字，都可以当做对象使用，也可当做构造方法使用。

当做对象使用

用法： this. 属性或 this. 方法， super. 属性或 super. 方法

此时的 this 表示当前类的对象， super 表示当前类的父类对象

class Person{
private String name;
public void setName(String name){
//这里的this表示当前类的对象Person对象
//相当于Person p = new Person();中的p
this.name=name;
}
public String getName(){
return name;
}
}
class Man extends Person{
void fun(){
//这里的super表示当前类的父类对象
//Person p = new Person();
//super表示上句话中的p
System.out.println(super.getName());
}
}

当做构造方法使用

用法： this([ 参数 ]) 或 super([ 参数 ])

此时的 this([ 参数 ]) 表示当前类的某个构造方法。如 this() 表示当前类的无参构造方法。

super([ 参数 ]) 表示当前类的父类的某个方法。如 super() 表示当前类的父类的无参构造方法。

如果当做构造方法使用时，只能写在另一个构造方法的第一行。

class Person{
String name;
int age;
Person(){
}
Person(String name,int age){
this.name=name;
this.age=age;
}
}
class Woman extends Person{
Woman(){
super("admin",20);
}
}
class Main{
public static void main(String[] args){
//调用Woman中的无参构造方法
//super("admin",20),执行父类中的 Person(String name,int age)
new Woman();

注意
如果父类中有无参数的构造方法，在子类的构造方法中，可以不写super()，默认自动调用。
如果父类中有带参数的构造方法，没有无参数的构造方法，在子类的构造方法中，必须要有super([参
数])。
父类和子类中都没有构造方法(只有默认的无参构造方法)

class Father{
//默认会有
/*
public Father(){}
*/
}
class Son extends Father{
//默认会有
/*
public Son(){
super();
}
*/
}

父类中没有无参构造方法，子类中就必须调用父类中对应的构造方法{

class Father{
String name;
//由于该构造方法的出现，默认无参数的构造方法就会失效
Father(String name){
this.name=name;
}
}
//这时子类继承会报错
class Son extends Father{
//因为每个类中都有这段代码
/*
Son(){
//但当前继承的父类中没有无参构造方法
super();
}
*/
}
//解决方式1.给父类中添加无参构造方法
class Father{
String name;
Father(String name){
this.name=name;
}
Father(){
}
}
//解决方式2.子类中添加同样的构造方法，目的是为了调用父类中的对应构造方法
class Son extends Father{
Son(String name){
super(name);
}
}

}

包package

通过包可以将 .java 源文件进行结构化管理，相当于 windows 中的文件夹。

不同的包中，可以保存相同的 .java 源文件。

某个类在某个包中时，会在该类的代码最上加入 package 包名 ;

包的命名

包名通常使用公司域名的倒序形式。

如 baidu.com 是百度的域名，有一个 test 的项目，包名写为 com.baidu.test

包名中的 "." ，相当于进入文件夹

如 com.baidu.test ，会创建 3 个文件夹： com 下有 baidu ， baidu 下有 test 。

导入包

如 a 包中的类要使用 b 包中的类时，需要在 a 包中的类中，导入 b 包或 b 包中的某个类。

如在使用 Scanner 时，就需要导入 Scanner 所在的 java.util 包。 import java.util.Scanner ;

在 IDEA 中，如果是通过自动补全的形式写的代码，会自动导入该类，

或设置自动导包删包。

如果需要手动导入包，在报错的位置上按下快捷键 alt+ 回车，

如果多个类，类名相同但在不同的包中，使用该类时选择合适的包。

访问修饰符

访问修饰符可以限制某个类、属性或方法的访问权限

用法：

修饰类：访问修饰符 class 类名 {}

修饰属性：访问修饰符数据类型变量名 ;

修饰方法：访问修饰符返回值类型方法名 (){}

访问修饰符	含义	可以修饰
public	公共的	类、方法、属性
protected	方法、属性	不写
不写	默认的	类、属性、方法
private	私有的	方法、属性

访问权限表

final关键字

修饰属性

当 final 修饰属性时，该属性的值不可更改，这个属性称为常量。

常量在程序运行过程中，保存的值不能编号，所以定义常量时需要初始化。

常量名所有字母大写，多个单词之间用 _ 隔开。

final 数据类型 常量名;
final int NUM = 123;
final double PI = 3.14;

修饰方法

当 final 修饰方法时，该方法不能被重写。

在方法的返回值前加上 final 。

public class Father{
public final void fun(){
}
}
public class Son extends Father{
//会报错，无法对final方法进行重写
@Override
public void fun(){
}
}

修饰类

当 final 修饰类时，该类不能被继承。

Object类

是 java 中所有类的父类。每个类都是这个类的子类，但没有使用 extends 体现出来

该类中定义了很多方法，通常需要进行重写。

对象造型/对象转型/cast

类似于原始类型中的数据类型转换。对象 A 转换为对象 B 的过程，称为对象转型。

在非继承关系的两个对象中，无法转型。

向下转型

父类对象转换为子类对象的过程，称为向下转型。 强制转换

//一个父类对象
Object obj = new Object();
//默认无法直接将obj使用Person对象接收
//"强制转换"
Person p = (Person) obj;

向上转型

子类对象转换为父类对象的过程，称为向上转型。 自动转换

//一个子类对象
Person p = new Person();
//默认子类对象可以用父类变量接收 多态
Object obj = p;

重写equals方法

如果两个对象的属性全部相同，在日常的业务逻辑中，可以视为这两个对象是同一个对象。

但是默认使用 new 创建的对象，就算属性一致，也是不同的内存地址，

如果用 == 比较，比较的是对象的内存地址，地址不同，返回 false 。

所以对象比较相同不能使用 ==

这时就需要自定义一套比较的方法， Object 中有一个 equals 方法，用于比较两个对象是否相同，

但是 Object 中的 equals 方法用 == 比较，所以对该方法进行重写。

如两个 Student 的 id 、 name 、 sex 都一致，返回 true.

在IDEA中自动生成equals方法

在类中右键 generate 或快捷键 alt + insert ，选择 equals and hashcode ，选择属性。

如两个对象的 id 相同就视为同一个对象，可以只选择 id 属性；

如两个对象的所有属性相同才视为同一个对象，选择全部属性。

同时生成的 hashcode() 可以删除。

Manager类

面向对象三大特性--多态

子类的对象保存在父类的变量中。

父类变量 = new 子类 ();

多态的应用

当某个方法的参数为父类变量时，可以传递一个子类对象。

这样就能在传递不同的子类对象时，表现出不同的形态。

如要定义动物发出叫声的方法，参数是猫，输出猫对象的叫的方法 " 喵喵 " ，参数是狗，输出狗对象的叫

的方法 " 汪汪 " 。

不用多态，需要写很多重载的方法，参数为猫或狗或其他类型。

使用多态，只需一个方法，参数为动物类，在动物类中定义叫的方法，让子类猫类狗类对其进行重写。

这时调用动物的叫的方法，实际会根据动物子类对象，调用具体子类重写后的方法。

多态的前提

在继承关系中

父类的变量保存子类的对象 ( 向上转型 )

abstract抽象的

修饰方法

使用： 访问修饰符 abstract 返回值类型方法名 ( 参数列表 );

如果一个方法的方法体无法描述，是由其子类进行重写后使用，可以将这个方法定义为抽象方法。

该方法就可以去掉方法体部分，该方法的所在类，也必须是一个抽象类，使用 abstract 修饰。

修饰类

使用： 访问修饰符 abstract class 类名 {}

如果一个类中有抽象方法，这个类必须也是一个抽象类。

//当一个类中有抽象方法时，这个类也必须是抽象类
public abstract class Fruit{
//当一个方法没有方法体时，这个方法定义为抽象方法
public abstract void eatIt();
}

abstract关键字特点

修饰类：被修饰的类称为抽象类

抽象类不能被实例化 ( 不能创建对象 ) ；

抽象类中有构造方法，在创建其子类对象时自动调用。

抽象类中可以有普通方法，通过其子类对象主动调用。

抽象类中定义的所有抽象方法，子类要么全部进行重写，要么也定义为抽象类。

修饰方法：被修饰的方法称为抽象方法

抽象方法没有方法体

抽象方法只能出现在抽象类中

abstract 不能修饰构造方法和静态方法

抽象相关面试题

抽象类的特点？

抽象类是使用 abstract 修饰的类，除了不能创建对象、能定义抽象方法外，与普通类一样。

抽象方法的特点？

抽象方法是使用 abstract 修饰的方法，没有方法体。非抽象子类必须要对父类中的抽象方法进

行重写。

抽象类中有构造方法吗？

有构造方法，但不是通过 new 该类对象时调用，而是在 new 其子类对象时自动调用。

执行某个类的构造方法时，一定会创建这个类的对象吗？

不一定

如果是普通类，在执行构造方法时，一定会创建对象

如果是抽象类，在执行构造方法时，不会创建自身对象，只会创建其子类对象

接口interface

在 Java 中，数据类型分为基本类型和引用类型。

引用类型包含：数组、类和接口。

所以接口是一种数据类型，类似于类，在定义接口的时候，使用 interface 替换 class 。

由于 Java 是单继承，如果类 A 既要继承类 B 中的内容，也要继承类 C 中的内容时，

如果用 "extends class 名 " ，只能选择一个类继承，

但使用 implements interface 名 1,interface 名 2... 就能同时 " 继承 " 多个 " 父类 ". 这里的 " 父类 " 就是接口。

通常用 extends 表示类 A 继承类 B ，用 implements 表示类 A 实现接口 A, 接口 B...

一个类可以同时 implements 实现 (" 继承 ") 多个接口。

extends和implements

类 A extends 类 B

类 A 当做类 B 的子类，称为继承

类 A implements 接口 A ，接口 B...

类 A 当做类 B 的实现类，称为实现

接口 A extends 接口 B

接口 A 继承接口 B

类 A extends 类 B implements 接口 A ，接口 B...

类 A 是类 B 的子类，同时也是接口 A ，接口 B 的实现类

什么时候使用接口

如果想要让某个类作为多个 " 类 " 的子类时，将这些 " 父类 " 定义为接口

如果某个类中的所有方法都是抽象方法时，将这个抽象类改为接口

Main

抽象类和接口的异同

抽象类是一个类，用 abstract class 定义

有构造方法，不能创建对象，在创建子类对象时自动调用父抽象类中的构造方法

抽象类中可以有非抽象方法

抽象类被子类继承时，用 extends 关键字。子类需要重写父抽象类中的所有抽象方法

子类只能继承一个抽象类

抽象类中可以定义成员变量

接口不是一个类，用 interface 定义

没有构造方法，不能创建对象

接口中定义抽象方法时，无需加 public abstract 修饰符

接口中可以存在被 default 或 static 修饰的方法

接口被子类实现时，用 implements 关键字。子类需要重写父接口中的所有抽象方法

子类可以实现多个接口，用逗号隔开

接口中定义的属性都是公共的静态常量，被 public static final 修饰，必须要有初始值

相同点

接口和抽象类都无法创建对象

接口的实现类和抽象类的子类，都需要重写抽象方法

接口是一个完全抽象类。 JDK1.8 之后可以在接口中定义有方法体 ( 被 default 或 static 修饰 ) 的方法。

static静态的

每次 new 创建一个对象，都会在堆空间中开辟一块区域，这个过程是需要花费时间和空间的。

在栈空间中，只会定义变量，保存堆空间中某块区域的地址。通过变量访问堆空间中对应地址的数据。

如果多个对象都有相同的属性或方法时，可以将这些公共的属性和方法使用 static 修饰，

让其成为 静态数据 ，在 类加载的时候就保存在静态区中

在不使用静态成员时

概念

static 是一个修饰符，可以修饰属性、方法、代码块。

被 static 修饰的内容，称为静态成员。静态成员在类加载时就保存到内中。

访问静态成员时，可以不用创建对象，直接通过类名访问。

如 Math 中的所有属性和方法，都是静态的，都通过 Math 直接访问。

定义和访问

什么时候使用static

如果某个属性或方法被高度重用时，可以将其定义为 static 静态的。

这样这些属性和方法在类加载时就会加载到内存中，从而直接通过类名即可访问。

static特点

静态方法中只能使用静态成员，不能使用非静态成员

成员变量、局部变量、静态常量

成员变量：定义在类中的变量

成员变量随着对象的创建而存在，随着对象的回收而销毁。

作用范围在类内部，成员变量有初始值。

局部变量：定义在方法中的变量

局部变量随着方法的调用而存在，随着方法执行结束而销毁。

作用范围在方法内容，局部变量没有初始值，必须赋值后才能使用。

静态常量：被final、static修饰的成员变量

静态常量随着类加载而存在，随着类的销毁而销毁 ( 通常程序运行结束 ).

作用范围在程序运行周期中，静态量有初始值，静态常量必须赋值。

public class ZOO {
//静态常量
public static final String ZOO_NAME = "重庆动物园";
//成员变量
private String address;
public ZOO(String address) {
this.address = address;
}
//静态方法
public static void welcome() {
//只能使用静态常量
System.out.println("欢迎光临" + ZOO_NAME);
}
//成员方法
public void sayHello(Animal animal) {
//局部变量
String str = "你好";
System.out.println(ZOO_NAME + "中的" + animal.getType() + "打招呼说" +
str);
System.out.println("地址："+address);
}
}
public class Animal {
private String type;
public Animal(String type){
this.type=type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
public class Main {
public static void main(String[] args) {
ZOO.welcome();
Animal bear = new Animal("棕熊");
new ZOO("杨家坪").sayHello(bear);
}
}

枚举

Java 中的枚举是一个特殊的类，是一些常量的集合。

如星期可以用数字 1-7 表示，也可以用 " 周一到周天 " 表示，

也可以用 SUN,MON,TUE,WED,THU,FRI,SAT 这些来表示。

这三种都可以称为枚举，对星期这个概念进行枚举。

定义枚举类型

public enum 枚举类型名{
常量1,常量2...常量N
}

使用枚举类型

枚举类型名 . 常量名 ;

package test1;
/*
* 定义枚举类型
* 使用enum关键字替换class
* 枚举是一个特殊的"类"，
* 将某个事物使用指定的内容进行一一例举
* */
public enum Week {
//定义一组枚举类型的常量集合
SUN,MON,TUE,WED,THU,FRI,SAT
}
package test1;
public class Main {
public static void main(String[] args) {
//遍历自定义的枚举类型
//for (Week value : Week.values()) {
// System.out.println(value);
//}
System.out.println("请输入星期的简写");
Scanner sc = new Scanner(System.in);
String input = sc.next();
//根据字符串获取对应的枚举数据
Week week = Week.valueOf(input);
//判断枚举类型
switch (week) {
case SUN:
System.out.println("星期天");
break;
case MON:
System.out.println("星期一");
break;
case TUE:
System.out.println("星期二");
break;
case WED:
System.out.println("星期三");
break;
case THU:
System.out.println("星期四");
break;
case FRI:
System.out.println("星期五");
break;
case SAT:
System.out.println("星期六");
break;
default:
System.out.println("单词有误");
}
}
}