一、** final关键字
1、final修饰变量
final修饰的基本数据类型的变量可以初始化，不能再更改。
/**
* @document: final修饰变量
* @Author:SmallG
* @CreateTime:2023/7/27+9:17
*/
public class Demo01 {
public static void main(String[] args) {
//在方法中声明的变量就是局部变量
final int a; //声明一个final的变量
a = 5; //只能赋值一次 第一次赋值成为初始化
System.out.println(a); //5
// a = 10; //编译错误 final修饰的局部变量 不能修改值
final int b =10; //在声明变量的时候同时初始化 不能再次赋值
}
}（1）final修饰局部变量
方法中的变量和方法的参数都属于局部变量。当final修饰引用类型变量时对象的首地址不能修改，但是对象的内容可以修改。
/**
* @document: final修饰局部变量
* @Author:SmallG
* @CreateTime:2023/7/27+9:17
*/
public class Demo01 {
public static void main(String[] args) {
//在方法中声明的变量就是局部变量
//final修饰引用类型变量
//变量中存的是变量的首地址
//初始化后不能再修改
//但是变量中的值可以修改
final int[] arr = {5, 10};
System.out.println(Arrays.toString(arr)); //[5, 10]
arr[0] = 1;
System.out.println(Arrays.toString(arr)); //[1, 10]
//arr = new int [10];//报错： arr的引用不能改变
final Aoo aoo = new Aoo(); //aoo 为引用类型变量
//aoo = new Aoo(); //报错引用类型不能改变
aoo.c =10; //变量的内容可以改变
//aoo = null; //aoo引用中保存的是地址不能修改
}
}
class Aoo {
int c = 5;
}
final修饰方法的参数：
/**
* @document: final修饰方法的参数
* @Author:SmallG
* @CreateTime:2023/7/27+9:36
*/
public class Demo02 {
public static void main(String[] args) {
Boo boo = new Boo();
boo.sum(5, 10); //在调用时进行初始化赋值
}
}
class Boo {
public void sum(int a, final int b) {
a = 10;
//b = 20; //报错：方法的参数使用final修饰 不能再次赋值
System.out.println(a + b);
}
}（2）final修饰类的成员变量
/**
* @document:final修饰类的成员属性（成员变量/实例变量）
* @Author:SmallG
* @CreateTime:2023/7/27+9:43
*/
public class Demo03 {
public static void main(String[] args) {
Coo coo1 = new Coo();
System.out.println(coo1.a + " " + coo1.b); //5 3
Coo coo2 = new Coo(10);
System.out.println(coo2.a + " " + coo2.b); //5 10
//coo2.a = 15; 报错：不能修改final修饰的成员属性值
}
}
class Coo {
final int a = 5; //在声明的时候直接初始化
final int b;
//不能有默认构造器 （如果非要有需要将b的值进行初始化
public Coo() {
this.b = 3;
}
public Coo(int b) {//在构造器中完成初始化
this.b = b;
}
}2、final修饰方法
final修饰的方法不能在子类中重写。
/**
* @document: final修饰方法
* @Author:SmallG
* @CreateTime:2023/7/27+10:09
*/
public class Demo04 {
public static void main(String[] args) {
Doo doo = new Doo();
doo.hello(); //Hello World
SubDoo subDoo = new SubDoo();
subDoo.hello(); //Hello World
}
}
class Doo {
public final void hello() {
System.out.println("Hello World");
}
}
class SubDoo extends Doo {
//final修饰的方法可以被继承 但是不能被重写
/*public final void hello(){
报错：不能被重写
}*/
}3、final修饰类
final修饰的类不能再被继承派生出子类，在实际开发中一般禁止使用final声明类。
/**
* @document: final修饰类
* @Author:SmallG
* @CreateTime:2023/7/27+10:21
*/
public class Demo05 {
public static void main(String[] args) {
Eoo eoo = new Eoo(); //可以创建相应的对象并且运行方法
eoo.hello(); //Hello World
}
}
final class Eoo {
public void hello() {
System.out.println("Hello World");
}
}
/*class Foo extends Eoo{
编译错误：被final修饰的类不能被继承
}*/二、** static关键字
1、修饰变量
成员变量有三种：实例变量、静态变量、常量
实例变量：是属于每个对象的属性，每个对象中都有一份
静态变量：是属于类的变量，只有一份，全体对象共享的同一份变量
常量：是不变的常数
静态变量：
使用static修饰的变量时静态变量，全体对象共享的一份变量，用静态变量存储程序中只有一个就足够的数据，静态变量和类的信息一起存储在方法区，static不能直接修饰局部变量。
静态变量工作原理：
第一次运行时，字节码文件会被分配到方法区，类中的静态变量此时在方法区中分配出来，字节码文件只加载一次。
/**
* @document: static修饰成员属性 被修饰的属性称为静态成员 属于整个类
* 类的所有对象共享这一个数据
* @Author:SmallG
* @CreateTime:2023/7/27+10:34
*/
public class Demo06 {
public static void main(String[] args) {
Foo foo1 = new Foo();
Foo foo2 = new Foo();
foo1.a = 5;
foo2.a = 10; //修改的不是一个存储位置的变量
foo1.b = 20;
foo2.b = 30; //修改的是同一个位置的变量
System.out.println(foo1.a); //5
System.out.println(foo2.a); //10
System.out.println(foo1.b); //30
System.out.println(foo2.b); //30
//static修饰的成员属性不推荐使用对象访问，推荐使用类直接访问
Foo.b = 50;
}
}
class Foo {
int a; //普通的成员属性
static int b; //static修饰的属性称为类属性/类变量 只有一份 被全体对象共享
public void hello(){
//static int age =10; static不能直接修饰局部变量
}
}
static final一起使用
同时使用时声明称为静态常量，不能被改变。
/**
* @document: 常量 static final 常量在声明的时候就赋值 以后不可修改
* @Author:SmallG
* @CreateTime:2023/7/27+11:15
*/
public class Demo07 {
public static void main(String[] args) {
System.out.println(Message.MSG_LOGIN_FAILED);
System.out.println(Message.MSG_LOGIN_SUCCESS);
}
}
class Message {
//用static final修饰的变量 名字采用全大写 单词组合用下划线分开
public static final String MSG_LOGIN_FAILED = "用户名或密码错误";
public static final String MSG_LOGIN_SUCCESS = "登录成功";
}常量的细节：
- 软件中不能改变的数据，应该都定义常量
- 同时使用static final修饰，两个关键字可以调换
- 常量必须初始化
- 一般常量名都是大写字母，多个单词使用下划线分割开
2、修饰方法
静态方法是属于类的方法。属于类的方法就可以直接使用类名直接引用方法。比如：Math.random()就是一个静态方法。
静态方法不能访问非静态成员，普通方法可以访问非静态成员。这里静态成员指成员属性和方法。
/**
* @document: 静态方法 使用static关键字修饰的方法 可以直接用类名访问
* @Author:SmallG
* @CreateTime:2023/7/27+14:02
*/
public class Demo08 {
public static void main(String[] args) {
Person.add(3, 5); //8
//成员方法只能通过对象访问
Person person = new Person("tom");
person.WhoRY();
person.add(6,9);//15 对象也可以访问静态方法 不推荐
//我是tom
//10
WaWo(); //可以直接访问本类中的静态方法
// HH(); 报错：不可以直接访问本类中的普通方法
}
public static void WaWo(){
System.out.println("这里是静态方法");
}
public void HH(){
System.out.println("这里是普通方法");
}
}
class Person {
String name;
static int num = 10;
public Person(String name) {
this.name = name;
}
//静态方法不能用this 静态方法属于整个类 this是属于对象的
//静态方法不能访问非静态成员
public static void add(int a, int b) {
System.out.println(a + b);
// System.out.println(name); 报错：静态方法不能访问非静态成员(成员属性和方法)
System.out.println(num); //10
}
public void WhoRY() {
System.out.println("我是" + this.name);
System.out.println(num); //普通方法可以访问静态成员
}
}3、static的其他用法
代码块
/**
* @document: 代码块 在类中直接使用一对{}编写的代码
* @Author:SmallG
* @CreateTime:2023/7/27+14:27
*/
public class Demo09 {
public static void main(String[] args) {
Goo goo1 = new Goo(); //属性成功初始化
Goo goo2 = new Goo(); //属性成功初始化
System.out.println(goo1.name); //Tom
System.out.println(goo2.name); //Tom
}
}
class Goo {
String name;
//每次创建对象，都会调用代码块中的内容
{
name = "Tom";
System.out.println("属性成功初始化");
}
}静态代码块
在类加载期间执行，只加载一次。
/**
* @document: 静态代码块 在加载类的时候（创建类的对象或访问类的静态成员）执行 以后不再执行
* @Author:SmallG
* @CreateTime:2023/7/27+14:33
*/
public class Demo10 {
public static void main(String[] args) {
//创建对象
/*Hoo hoo1 = new Hoo(); //静态成员初始化成功
Hoo hoo2 = new Hoo(); //静态代码块只能执行一次*/
System.out.println(Hoo.name); //静态成员初始化成功 Tom 先加载类 静态代码块立即执行
}
}
class Hoo {
static String name;
//静态代码块只能访问静态成员
static {
System.out.println("静态成员初始化成功");
name = "Tom";
}
}静态导入
import static static1.Person.*; //加载Person里面的所有组件
/**
* @document: 静态导入 在导包的时候前面加static
* @Author:SmallG
* @CreateTime:2023/7/27+15:05
*/
public class Demo11 {
public static void main(String[] args) {
eat();
sleep();
talk();
}
}三、**abstract抽象
1、抽象类
抽象类不能直接实例化创建对象，是个半成品创建对象没有意义，只包含部分的属性和方法。
abstract和final不可以同时修饰一个类，final关键字不能被继承，而抽象类如果不能被继承就没有了意义。
抽象类中可以创建构造器，用于子类的继承。
/**
* @document: 父类
* @Author:SmallG
* @CreateTime:2023/7/27+15:30
*/
//抽象类不能被实例化 但是可以被继承
public abstract class Person {
String name;
int age;
public void whoru() {
System.out.println("我是" + name);
}
}
/**
* @document:
* @Author:SmallG
* @CreateTime:2023/7/27+15:33
*/
public class Student extends Person {
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void study() {
System.out.println("我在学习");
}
}
/**
* @document:
* @Author:SmallG
* @CreateTime:2023/7/27+15:37
*/
public class Teacher extends Person {
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public void teach() {
System.out.println("我在讲课");
}
}
/**
* @document:
* @Author:SmallG
* @CreateTime:2023/7/27+15:40
*/
public class Worker extends Person {
public Worker(String name, int age) {
this.name = name;
this.age = age;
}
public void work() {
System.out.println("我在工作");
}
}
/**
* @document: 测试类
* @Author:SmallG
* @CreateTime:2023/7/27+15:42
*/
public class Demo13 {
public static void main(String[] args) {
Student student = new Student("Tom", 12);
//创建老师对象
Teacher teacher = new Teacher("Jerry", 30);
//创建工人对象
Worker worker = new Worker("Spike", 25);
student.whoru(); //我是Tom
student.study(); //我在学习
teacher.whoru(); //我是Jerry
teacher.teach(); //我在讲课
worker.whoru(); //我是Spike
worker.work(); //我在工作
//问题：如果创建person对象 父类没有初始化 不应该让他们创建对象
//java编译器检查 不允许创建抽象类的对象
//Person person = new Person();
//person.whoru();
}
}
2、抽象方法
使用abstract关键字声明，不包含方法体
（思想是重点）抽象方法的语法：
抽象类可以没有抽象方法，但是一个类如果有抽象方法就一定要是抽象类。子类继承抽象类要重写所有的抽象方法，否则报错。
抽象方法的意义在于便于程序的统一管理。
/**
* @document: 父类
* @Author:SmallG
* @CreateTime:2023/7/27+15:30
*/
//抽象类不能被实例化 但是可以被继承
public abstract class Person {
//抽象方法 不能有方法体
public abstract void schedule();
}
/**
* @document:
* @Author:SmallG
* @CreateTime:2023/7/27+15:33
*/
public class Student extends Person {
@Override
public void schedule() {
System.out.println("吃饭 听课");
}
}
/**
* @document: 测试类
* @Author:SmallG
* @CreateTime:2023/7/27+15:42
*/
public class Demo13 {
public static void main(String[] args) {
Student student1 = new Student("SmallG",23);
student.schedule();
}
}四、练习
计算汽车租赁价格
汽车租赁公司出租多种车辆，车型和租金情况如下图所示：
编写程序实现租赁价格的计算。
具体需求：
1、车辆分为轿车和客车两大类，它们都继承自抽象类MotoVehicle，如下图所示：
2、抽象类MotoVehicle
- 有参构造器：带有两个参数（String类型的汽车牌照和品牌）
- 方法getNo()：返回String 类型的汽车牌照
- 方法getBrand()：返回String 类型的品牌（宝马或者别克）
- 抽象方法calRent()：需要一个int类型的参数表示被租赁的天数，用于计算租金
/**
* @document: 父类抽象类
* @Author:SmallG
* @CreateTime:2023/7/27+8:04
*/
public abstract class MotoVehicle {
String no; //汽车牌照
String brand; //汽车品牌
//无参构造器
public MotoVehicle() {
}
//有参构造器
public MotoVehicle(String no, String brand) {
this.no = no;
this.brand = brand;
}
//get方法
public String getNo() {
return no;
}
public String getBrand() {
return brand;
}
//抽象方法
public abstract int calRent(int days);
}3、子类 Car：表示轿车
- 有参构造器：带有三个参数（String类型的汽车牌照、品牌、车型）
- 方法getType()：返回String 类型的车型（如果是宝马，则为 550i）
- 方法setType()：带有Stirng类型的参数，设置车型
- 重写方法calRent()：根据品牌及车型，找到对应的日租金，乘以租用天数，计算租金
/**
* @document: 汽车类，表示轿车
* @Author:SmallG
* @CreateTime:2023/7/27+8:10
*/
public class Car extends MotoVehicle {
String type;
//无参构造器
public Car() {
}
//有参构造
public Car(String no, String brand, String type) {
super(no, brand);
this.type = type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public int calRent(int days) {
if (brand.equals("宝马") && type.equals("550i")) {
return days * 500;
} else if (brand.equals("别克商务舱") && type.equals("GL8")) {
return days * 600;
} else {
return days * 300;
}
}
}4、子类 Bus：表示客车
- 有参构造器：带有三个参数（String类型的汽车牌照和品牌、int类型的车座位数）
- 方法getSeatCount ()：返回int 类型的车座位数
- 方法setSeatCount ()：带有int 类型的参数，设置车座位数
- 重写方法calRent()：根据座位数，找到对应的日租金，乘以租用天数，计算租金
/**
* @document: 表示客车
* @Author:SmallG
* @CreateTime:2023/7/27+8:17
*/
public class Bus extends MotoVehicle {
int seatCount;
public Bus() {
}
public Bus(String no, String brand, int seatCount) {
super(no, brand);
this.seatCount = seatCount;
}
public int getSeatCount() {
return seatCount;
}
public void setSeatCount(int seatCount) {
this.seatCount = seatCount;
}
@Override
public int calRent(int days) {
if (seatCount <= 16) {
return days * 800;
} else {
return days * 1500;
}
}
}5、定义测试类TestRent，并实现车辆的租赁计算。
运行效果如下所示：
/**
* @document: 测试类
* @Author:SmallG
* @CreateTime:2023/7/27+8:20
*/
public class TestRent {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int sum = 0;
System.out.println("欢迎您来到汽车租赁公司！");
System.out.print("请输入要租赁的天数：");
int days = scanner.nextInt();
boolean s1 = true;
int num1 = 0;
while (s1) {
System.out.print("请输入要租赁的汽车类型（1：轿车\t 2、客车）：");
num1 = scanner.nextInt();
if (num1 != 1 && num1 != 2) {
System.out.println("请输入正确的汽车类型！");
} else {
s1 = false;
}
}
//选择轿车
int num2 = 0;
if (num1 == 1) {
boolean s2 = true;
while (s2) {
System.out.print("请输入要租赁的汽车品牌（1、宝马\t 2、别克）:");
num2 = scanner.nextInt();
if (num2 != 1 && num2 != 2) {
System.out.println("请输入正确的汽车品牌！");
} else {
s2 = false;
}
}
} else {//选择客车
boolean s4 = true;
int num5 = 0;
while (s4) {
System.out.print("请输入要租赁的客车品牌（1、金杯\t 2、金龙）:");
num5 = scanner.nextInt();
if (num5 != 1 && num5 != 2) {
System.out.println("请输入正确的汽车品牌！");
} else {
s4 = false;
}
}
boolean s5 = true;
int num6 = 0;
while (s5) {
System.out.print("请输入客车的座位数:");
num6 = scanner.nextInt();
if (num6 <= 0) {
System.out.println("请输入正确的座位数！");
} else {
s5 = false;
}
}
if (num5 == 1) {
Bus bus = new Bus("京AU8769", "金杯", num6);
sum = bus.calRent(days);
System.out.println("分配给您的汽车牌号是:" + bus.no);
}else{
Bus bus = new Bus("京AU8769", "金龙", num6);
sum = bus.calRent(days);
System.out.println("分配给您的汽车牌号是:" + bus.no);
}
}
//轿车型号
boolean s3 = true;
int num3 = 0;
int num4 = 0;
if (num2 == 1) { //轿车宝马
while (s3) {
System.out.print("请输入轿车型号（1、550i）：");
num3 = scanner.nextInt();
if (num3 == 1) {
s3 = false;
} else {
System.out.println("请输入正确的轿车型号！");
}
}
Car car = new Car("京BK5543", "宝马", "550i");
sum = car.calRent(days);
System.out.println("分配给您的汽车牌号是:" + car.no);
} else if (num2 ==2){//轿车别克
while (s3) {
System.out.print("请输入轿车型号（1、GL8）：");
num4 = scanner.nextInt();
if (num4 == 1) {
s3 = false;
} else {
System.out.println("请输入正确的轿车型号！");
}
}
Car car = new Car("京BK5543", "别克商务舱", "GL8");
sum = car.calRent(days);
System.out.println("分配给您的汽车牌号是:" + car.no);
}
System.out.println();
System.out.println("顾客您好！您需要支付的租赁费用是" + sum + "。");
} }
