构造方法对象的创建步骤static关键字

构造方法/对象的创建步骤/static关键字/继承方inal法的重写/Final

构造方法概述和格式

A：构造方法的概述和格式

​ 创建对象，给对象中的成员进行初始化

B:构造方法格式特点

​ a:方法名与类名一样

​ b:没有返回值类型，连void都没有

​ c:没有具体的返回值

构造方法的重载及注意事项

A：案例

​ 构造方法的重载

B：构造方法注意事项

​ a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

​ b：如果我们给出了有参数的构造方法，系统将不再提供默认的无参构造方法。

​ 注意：这时候我们还想要使用无参的构造方法，就必须自己给出。建议永远自己给出无参的构造方法

C：给成员赋值的两种方式

​ a:setxxx（）方法

​ b:构造方法

public class Student {private String name;private int age;//构造方法：他的方法名和类名相同，没有返回值类型，连void也没有。//我自己定义类，默认存在一个空参的构造方法。//3.一旦你在类中，自己手动定义了有参构造，那么默认无参构造，就不存在了。如果你还想要用空参构造创建对象，建议你把空参构造手动写出来。//构造方法也可以重载。public Student() {System.out.println("空参构造方法调用了");}public Student(String name) {System.out.println("一个参数的构造方法调用了");this.name = name;this.age = 200;}public Student(String name, int age) {System.out.println("两个参数的构造方法调用了");this.name = name;this.age = age;}public String getName() {return name;}public class MyTest2 {public static void main(String[] args) {//借助空参构造完成类的实例化Student student = new Student();student.setName("王老虎");student.setAge(20);System.out.println(student);System.out.println(student.getName());System.out.println(student.getAge());System.out.println("====================================");//借助有参构造完成类的实例化Student student1 = new Student("abc");System.out.println(student1);System.out.println(student1.getName());System.out.println(student1.getAge());//采用有参构造，创建对象时，给该对象的实例变量赋值，比较方便。Student student2 = new Student("hehe", 100);System.out.println(student2.getName());System.out.println(student2.getAge());System.out.println(student2);}
}

一个人类的代码及其测试

A：案例

完善我们的学生类

1. B : 给成员赋值

​ a:setxxx()方法

​ b:构造方法

C：输出成员变量值的方法
a：通过getxxx()分别获取然后拼接

​ b：通过show()方法搞定

public class Person {String name;//private 私有的 是一个权限修饰符，可以修饰成员变量和成员方法，被修饰的成员，只能在本类中范围，外界无法直接访问//如果外界还想要访问age这个变量，我们可以提供公共的方法，让外界通过调用方法来设置获取私有成员变量的值。private int age;public void setAge(int nianling) {if (nianling > 0 && nianling <= 100) {age = nianling;}}public int getAge() {return age;}public void eat() {System.out.println("吃饭");}
}public class MyTest {public static void main(String[] args) {Person person = new Person();person.name = "张曼玉";//我们之前采用 对象名.成员变量明=值 这种方式给成员变量设置值，会把一些我们认为不合理的数据设置进去，那么我们认为这样不好。//我们需要对设置的数据进行一些判断，认为合理后才可以设置。//我们可以屏蔽掉 对象名.成员变量明=值 这种方式，那么怎么来屏蔽这种方式，我们可以使用private 关键字来屏蔽。//person.age = 2000; 报错age 访问不到，因为age被private修饰了。外界无法直接范围person.setAge(200);int age = person.getAge();System.out.println("姓名：" + person.name);System.out.println(age);//System.out.println("年龄：" + person.age);}
}

一个手机类的代码及测试

创建一个对象

A：画图演示

​ 画图说明一个对象创建过程做了哪些事情？

​ Student s=new Student();

步骤：

​ 1: 加载Student.class文件进内

​ 2：在栈内存为s开辟空间

​ 3: 在栈内存为学生对象开辟空间

​ 4: 对学生对象的成员变量进行默认初始化

​ 5：对学生对象的成员变量进行显示初始化

​ 6：通过构造方法为学生对象的成员赋值

​ 7：学生对象初始化完毕，把对象地址赋值给s变量

长方形案例

A：案例

​ 需求：

​ 定义一个长方形类，定义周长和面积和方法，然后定义一个Test类，进行测试。

public class Rectangle {//定义成员属性private double width;private double height;public Rectangle() {}public Rectangle(double width, double height) {this.width = width;this.height = height;}public double getWidth() {return width;}public void setWidth(double width) {this.width = width;}public double getHeight() {return height;}public void setHeight(double height) {this.height = height;}//定义获取周长的方法public double getPerimeter() {return (this.width + this.height) * 2;}//定义获取面积的方法public double getArea() {return width * height;}}public class MyTest {public static void main(String[] args) {Rectangle rectangle = new Rectangle();rectangle.setWidth(20);rectangle.setHeight(10);double perimeter = rectangle.getPerimeter();double area = rectangle.getArea();System.out.println(perimeter);System.out.println(area);System.out.println("=============================");Rectangle rectangle1 = new Rectangle(20, 50);System.out.println(rectangle1.getPerimeter());double area1 = rectangle1.getArea();System.out.println(area1);}
}

员工类案例练习

A:案例

​ 需求：定义一个员工的类，自己分析几个成员，然后给出成员变量，构造方法，getxxx()和setxxx()以及一个所有成员信息的方法。并测试。

static关键字的引入

A案例演示

​ 通过一个案例引入static关键字。

​ 人类：Person.每个人都有国籍，中国。

public class Person {String name;//static 静态的，可以修饰成员变量，修饰变量，此变量为一个共享变量，被该类所有的对象所共享，//被static 所修饰的成员是随着类的加载而加载，是优先于对象存在。// 也可以修饰成员方法static String citizenship = "中国";
}public class MyTest {public static void main(String[] args) {Person p1 = new Person();p1.name = "张三";p1.citizenship = "美国";Person p2 = new Person();p2.name = "李四";p2.citizenship = "英国";Person p3 = new Person();p3.name = "王五";p3.citizenship = "加拿大";//静态成员，属于类，我们建议通过类名直接调用，不需要使用对象调用，当然你使用对象调用可以，但是不推荐。//静态成员，属于类，所以静态变量，也称之为类变量Person.citizenship = "韩国";System.out.println(p1.name);System.out.println(p1.citizenship);System.out.println("================================");System.out.println(p2.name);System.out.println(p2.citizenship);System.out.println("================================");System.out.println(p3.name);System.out.println(p3.citizenship);}
}

static的内存图

A:画图演示：带有static的内存图

static关键字的特点

A：static关键字的特点

​ a:随着类的加载而加载

​ b:优于对象的存在

​ c:被类的所有对象所共享

​ 举例：咱们班级的学生应该共用一个班级编号

​ 其实这个特点也是在告诉我们什么什么时候使用静态？

​ 如果某个成员时被所有对象 所共享的，那么它就应该被定义静态。

​ 举例：饮水机（用静态修饰）

​ 水杯：(不能静态修饰)

​ d:通过类名调用

​ 其实它本身也可以对象名调用。

​ 推荐使用类名调用

​ 静态修饰的内容一般我们称其为：与类相关的，类成员

B：案例

​ static关键字的特点

public class Dog {public double num = 20;public static int a = 120;//非静态方法，既可以访问非静态的，也可以访问静态的。public void show() {System.out.println(num);System.out.println(a);}public void show2() {System.out.println(num);System.out.println(a);this.show();this.test();Dog.test();}//静态方法中，只能访问到静态成员，访问不到非静态成员。//被静态所修饰的成员，是随着类的加载而加载，是优先于对象而存在。//先有的访问不到后来才有的。//静态的只能访问静态的。public static void test() {// System.out.println(num);System.out.println(a);}//静态的只能访问静态的。public static void test2() {//静态方法里面不能存在this关键字，this代表一个对象，是后来才有的，静态方法里面访问不到//this.show();System.out.println(a);}
}

静态变量和成员变量的区别

A：所属不同

​ 静态变量属于类，所以也被称为类变量

​ 成员变量属于对象，所以也被实例变量（对象变量）

B：内存中位置不同

​ 静态变量存储于方法区的静态区，JDK1.7之后存储在堆内存中

​ 成员变量存储在堆内存

C：内存出现时间不同

​ 静态变量随着类的加载而加载，随着类的消失而消失

D：调用不同

​ 静态变量随着类名调用，也可以通过对象调用，推荐使用类名调用

​ 成员变量只能通过对象名调用

###如何通过JDK 提供的帮助文档

A：找到文档，打开文档

B: 点击显示，找到索引，出现输入框

C:你应该知道找到谁?举例：Scanner

D：看到这个类的结构（需不需要导包）

​ java.lang 包下的内容不需要我们手动导入

​ 其他包下的内容不需要我们手动导入

​ 类 API文档

​ 成员变量 字段摘要

​ 构造方法 构造方法摘要

​ 成员方法 方法摘要

E：看这个类的说明

F：看开始版本

G：看构造方法

H: 看成员方法

​ 看左边：

​ 看是否是static的，如果是我们就不需要创建对象，直接使用类名调用该方法就可以了，看返回值，返回值是什么，我们就 使用什么接收

​ 看右边：

​ 看参数列表：参数的个数，参数的类型：要什么参数我使用的时候，就传递什么参数

I：然后使用

学习Math类的随机数功能

打开JDK提供的帮助文档学习

A：math类概述

​ 类包含用于执行基本数学运算方法

B: math类的特点

​ 由于math类在Java.lang 包下，所以不需要导包。

​ 没有构造方法，因为它的成员全部是静态的。

C：获取随机数的方法

​ public static double random():返回带正号的double值，该值大于等于0.0且小于1.0.

D：我要获取一个1到100的随机数，怎么办？

​ int number = （int）（Math.random()*100+1）

猜数字小游戏案例

A：案例：需求：猜数字小游戏（数据在1到100之间）

public class MyTest {public static void main(String[] args) {//Math:关于数学方面的工具类/*  for (int i = 0; i < 100; i++) {//生成随机小数 范围 0---1之间的小数double v = Math.random();System.out.println(v);}*///我想要 1---100之间随机整数 包含1 和 100for (int i = 0; i < 1000; i++) {int v = (int) (Math.random() * 100 + 1);if (v == 1) {System.out.println(v);}}}
}public class GuessNumber {public static void main(String[] args) {int num = (int) (Math.random() * 100 + 1);Scanner sc = new Scanner(System.in);while (true) {System.out.println("请输入一个整数 1---100");int userNum = sc.nextInt();if (userNum > num) {System.out.println("猜大了");} else if (userNum < num) {System.out.println("猜小了");} else {System.out.println("恭喜你猜对了");break;}}}
}

代码块的概述和分类

A：代码块概述

​ 在Java中，使用{}括起来的代码被称为代码块。

B：代码块分类

​ 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程）。

C：常见代码块的应用

​ a:局部代码块

​ 在方法中出现，限定变量生命周期，及早释放，提高内存利用率

​ b:构造代码块

​ 在类方法外出现；多个构造方法中相同的代码存放在一起，每次调用构造都执行，并且在构造方法前执行

C：静态代码块

​ 在类中方法外执行，加了static修饰

​ 在类中方法外出现，并加上static修饰，用于给类初始化，在加载的时候就执行，并且只执行一次。

看程序写结果

class Student {static {System.out.println("Student 静态代码块");  //3}{System.out.println("Student 构造代码块");//46}public Student() {System.out.println("Student 构造方法");//57}}class StudentDemo {static {System.out.println("StudentDemo的静态代码块"); //1}public static void main(String[] args) {System.out.println("我是main方法"); //2Student s1 = new Student();Student s2 = new Student();}}

继承的引入和概述

A：继承概述

​ 多个类中存在相同属性和行为时，将这些内容抽取在一个单独的一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

B : 继承格式

​ 通过extends关键字可以实现类与类的继承

​ class子类名extends父类名{}

​ 单独的这个类称为父类，基类或者超类，者多个类可以被称为子类或者派生类。

继承案例以及它的好处和弊处

A：需求：

​ 学生类和老师类

​ 定义两个功能{吃饭，睡觉}

B：案例

​ 使用继承前

​ 使用继承后

public class MyTest {public static void main(String[] args) {//面向对象的三大特征：封装，继承，多态//封装：类，就是体现的封装的思想，封装了属性和功能。//继承：生活中的继承,儿子可以继承老子的财产。//Java中的继承：子类可以继承父类的成员。//我们使用关键字 extends 来让类和类之间产生继承关系。//继承的好处：//1.可以继承父类的成员，提高代码的复用性和维护性。//2.继承的弊端：让类和类产生了关系，增加了耦合性，软件的设计原则，遵循高内聚，低耦合。//3.继承，其实就是把多个子类共性的部分，向上抽取到父类中。/**   开发的原则：高内聚，低耦合。耦合：类与类的关系内聚：就是自己完成某件事情的能力** */Zi zi = new Zi();zi.name = "王五";zi.age = 12;zi.sleep();zi.eat();zi.playGame();System.out.println(zi.name);System.out.println(zi.age);System.out.println("=======================================");Zi2 zi2 = new Zi2();zi2.name = "李四";zi2.age = 25;zi2.sleep();zi2.eat();zi2.sing();System.out.println(zi2.name);System.out.println(zi2.age);}
}class Fu {String name;int age;public void eat() {System.out.println("吃饭饭");}public void sleep() {System.out.println("睡觉觉");}}class Zi extends Fu {public void playGame() {System.out.println("玩游戏");}
}class Zi2 extends Fu {public void sing() {System.out.println("唱歌");}}

C : 继承的好处

​ a:提高了代码的复用性

​ b：提高了代码的维护性

​ c:让类与类之间产生了关系，时多态的前提

E：继承的弊端

​ 类的耦合性增强了。

​ 开发的原则：高类聚，低耦合。

​ 耦合:类与类的关系

​ 内聚：就是自己完成某件事情的能力

java中类的继承特点

A：Java中类的继承特点

​ a:Java只支持单继承，不支持多继承。

​ 有些语言时支持多继承，格式：extend 类1，类2，，，

​ b:java支持多层继承

B:案例

​ Java类的继承特点

public class MyTest3 extends Object {public static void main(String[] args) {/**  Java中继承的特点：*  1.Java中只支持单继承，一个子类只能有一个直接父类，但是支持多层继承。*  2.子类只能继承父类非私有的成员。*  3.构造方法不参与继承，构造方法的作用就是，你在初始化子类时，先要初始化父类。**  Object类：是所有类的顶层父类，所有类都是直接或间接继承自他。*** */Son son = new Son();System.out.println(son.num);System.out.println(son.a);}
}class GrandFather extends Object {int num = 200;private int aaa = 20;
}class Father extends GrandFather {int a = 30;}

继承的注意事项和什么时候使用继承

A：继承的注意事项

​ a:子类只能继承父类所有非私有的成员{成员方法和成员变量}

​ b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法。

​ c:不要为了部分功能去继承

B:什么时候使用继承

​ 继承其实体现的是一种关系：“is a”.

​ 采用假设法。

​ 如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承

继承中成员变量的关系

A：子类中的成员变量和父类中的成员变量名称不一样

B: 子类中的成员变量和父类中的成员变量名称一样

​ 在子类访问一个变量的查找规则{就近原则}

​ a：在子类的方法局部范围中寻找，有就使用

​ b:在子类的成员范围找，有救使用

​ c:在父类的成员范围找，悠久使用

public class MyTest {public static void main(String[] args) {Zi zi = new Zi();zi.show(5);zi.test(800);}
}class Fu {int num = 10;}class Zi extends Fu {int a = 20;int num = 500;//变量的访问原则,就近原则：先在局部范围找，找到就使用，没找到，去本类的成员范围找，找到就使用，没找到去父类成员范围找，找到就使用。public void show(int c) {System.out.println(c);System.out.println(a);System.out.println(num);}//public void test(int num) {System.out.println(num); //800System.out.println(this.num); //500System.out.println(super.num); //10}
}

this和super的区别和应用

A：通过问题引出super

​ 子类局部范围访问父类成员变量

B: this和super的区别

​ this 代表的是本类对象的引用

​ super 代表的是父类存储空间的标识

C：this和super使用

​ a：调用成员变量

​ this.成员变量 调用本类的成员变量

​ super.成员变量 调用父类的成员变量

​ b:调用构造方法

​ this(…) 调用本类的构造方法

​ super(…) 调用父类的构造方法

​ c:调用成员方法

​ this.成员方法 调用本类的成员方法

​ super.成员方法 调用父类的成员方法

继承中构造方法的关系

A：案例

​ 子类中的所有构造方法默认都会访问父类中参数的构造方法

B: 为什么？

​ 因为子类会继承父类中的数据，可能还会使用父类的数据

​ 所以，子类在初始化之前，一定要先完成父类数据的初始化

原因：

​ 每一个构造方法的第一条语句默认都是：super()

public class MyTest {public static void main(String[] args) {//Father father = new Father();//当我们创建子类对象时，会先去调用父类的构造方法？为什么？//我们在创建子类对象时，子类要继承父类的成员，甚至还要使用父类的成员，如果他不先完成父类数据的初始化，子类何谈继承父类数据以及使用父类数据呢？//在每个构造方法中有一条默认语句 super() 这条语句就是去访问父类的空参构造，先调用父类的空参构造方法，完成父类数据的初始化。Son son = new Son();}
}class Father extends Object {int num = 100;public Father() {super();System.out.println("Father父类的空参构造执行了");}
}class Son extends Father {int a = 20;public Son() {super();System.out.println("Son子类的空参构造执行了");System.out.println(num);}

继承中构造方法的注意事项

A：案例：

​ 父类中没有无参的构造方法，子类怎么办？

​ a:在子类中添加一个无参的构造方法

​ b:子类通过super去显示调用父类其他的带参的构造方法

​ c:本类通过this去调用本类的其他构造方法

​ 本类其他构造也必须首先访问父类构造

B:注意事项

​ super(…)或者this(…)必须出现在第一条语句上

public class Student {public Student(int num) {System.out.println("student 有参构造执行了" + num);}
}public class Boy extends Student {public Boy() {super(10); //必须位于第一行System.out.println("boy空参构造执行了");}public Boy(int num) {super(num);System.out.println("boy有参构造执行了");}
}

看程序写结果

class Fu{public int num = 10;public Fu(){System.out.println("fu"); }}class Zi extends Fu{public int num = 20;public Zi(){System.out.println("zi"); }public void show(){int num = 30;System.out.println(num);//30System.out.println(this.num); //20System.out.println(super.num); //10}}class Test {public static void main(String[] args) {Zi z = new Zi();z.show();}}

class Fu {static {System.out.println("静态代码块Fu"); //1   {System.out.println("构造代码块Fu"); //  3}public Fu() {System.out.println("构造方法Fu");   //  4}}class Zi extends Fu {static {System.out.println("静态代码块Zi");//  2}{System.out.println("构造代码块Zi"); //  5}public Zi() {super();System.out.println("构造方法Zi"); //  6}}class Test{public static void main(String[] args){Zi z = new Zi(); //请问执行结果。}}

继承中成员方法关系

A：案例：

​ a：当子类的方法名和父类的方法名不一样的时候

​ b: 当子类的父类名和父类的方法名一样的时候

​ 通过子类调用方法 ：

​ a：先看子类中有没有该方法，如果有就使用

​ b: 在看父类中有没有该方法，有就使用

​ c:如果没有就报错

public class MyTest {public static void main(String[] args) {Zi zi = new Zi();//zi.hehe();zi.haha();//方法重写：当子类出现了和父类一模一样（返回值类型一样，方法名一样，形参一样）的方法时，就会发生子类方法覆盖父类方法的现象，这种现象，我们称之为方法重写。//所以在调用时，会以子类重写过后的为准。//为什么要有方法重写这个机制？}
}class Fu {public void fuShow() {System.out.println("父类show");}public void haha() {System.out.println("父类的haha方法");}
}class Zi extends Fu {public void ziShow() {System.out.println("zi show");}public void hehe() {this.ziShow();super.fuShow();this.fuShow();}public void haha() {System.out.println("子类的haha方法");}
}

方法重写概述及其应用

A：什么是方法重写

​ 子类中出现了和父类一摸一样的方法声明（方法名，参数列表，返回值类型），也被称为方法覆盖，方法复写。

B:方法重写的应用：

​ 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
​ 这样，即沿袭了父类的功能，又定义了子类特有的内容。

C：案例

​ a:定义一个手机类。

​ b:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报

public class MyTest {public static void main(String[] args) {IPhone iPhone = new IPhone();iPhone.call();}
}class Phone {public void call() {System.out.println("语音通话功能");}
}class IPhone extends Phone {//我们通过方法重写，可以扩展父类的功能@Overridepublic void call() {super.call(); //去沿袭父类已经实现好的功能System.out.println("视频通话功能");}
}	

方法重写的注意事项

A：注意

​ a：父类中私有方法不能被重写

​ 私有的方法无法被继承

​ b:子类方法重写的时候，访问的权限不能更低

​ 最好是一致的

​ c:父类的静态方法，不参与重写

B：案例

public class Zi extends Fu {//Ctrl+O 重写父类方法@Overridepublic void hehe(int a, int b) {int sum = a + b;System.out.println(sum);}@Overrideprotected int haha(int a, int b) {int r = a * b;return r;}//@Override 静态方法，不参与重写。public static void staticMethod() {System.out.println("子类类的静态方法");}
}public class Fu {public void hehe(int a, int b) {System.out.println("fu hehe");}protected int haha(int a, int b) {System.out.println("fu haha");return a + b;}public static void staticMethod() {System.out.println("父类的静态方法");}
}public class MyTest {public static void main(String[] args) {//方法重载：可以让你在一个类中，定义多个同名方法，要求形参个数或形参类型不同就可以，不拿返回值类型区分。//方法重写：要有继承的先决条件，子类出现了和父类一模一样（形参列表，返回值类型，方法名一样）的方法，就会发生方法覆盖现象。//方法重写的注意事项：//1.父类私有的方法，子类不能重写，父类私有的方法，子类不能继承，何谈重写。//2.构造方法，没有重写这一说，父类的构造方法，就是我们在创建子类对象时，想要调用父类构造方法，完成父类数据的初始化。//3.静态方法不参与重写。//4.子类在重写父类方法的时候，权限修饰符要比父类的高，不能比父类低，或者跟父类一样，你直接点，跟父类一样，永远不会错。Zi zi = new Zi();Zi.staticMethod();Fu.staticMethod();}
}

面向对象(猫狗案例分析,实现及测试)

A:猫狗案例分析父类的由来:	首先我们需要分析具体的事物,分析完毕以后将共性的内容提取出来放在一个独立的类中(父类).
B:案例演示猫狗案例继承版
public class Animal {public void eat() {System.out.println("吃饭");}public void sleep() {System.out.println("睡觉");}
}public class Cat extends Animal {public void cacheMouse() {System.out.println("猫抓老鼠");}@Override //注解：可以检测该方法是不是重写父类的public void eat() {System.out.println("我爱吃鱼");}
}public class Dog extends Animal {public void lookDoor() {System.out.println("狗看门");}@Override //注解：  这个注解可以检测该方法，是不是重写父类的public void sleep() {System.out.println("狗白天睡觉");}
}public class MyTest {public static void main(String[] args) {//方法重写：当子类出现了和父类一模一样（返回值类型一样，方法名一样，形参一样）的方法时，就会发生子类方法覆盖父类方法的现象，这种现象，我们称之为方法重写。//所以在调用时，会以子类重写过后的为准。//为什么要有方法重写这个机制？//子类对父类的功能实现不满意，想要自己去实现，那么子类就提供一个和父类一摸一样的方法，// 按照自己的需求去重写，重写过后就会以自己的为准。Dog dog = new Dog();dog.eat();dog.sleep();dog.lookDoor();System.out.println("====================");Cat cat = new Cat();cat.sleep();cat.eat();cat.cacheMouse();}
}

final关键字概述

A:为什么会有final

​ 由于继承中有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法。这时候我们就可以使用关键字：final

B：final概述

​ final关键字是最终的意思，可以修饰类，变量，成员方法。

final关键字修饰类，方法以及变量的特点

A：final修饰特点

​ 修饰类： 被修饰的类不能被继承

​ 修饰方法 ： 修饰的方法不能被重写

​ 修手机变量: 被修饰的变量不能被重新赋值，因为这个量其实就是一个常量

​ fin

final关键字修饰局部变量

A：案例

​ 基本类型，是值不能被改变

​ 引用类型，是地址值不能被改变

public class MyTest {public final double A = 3.14;//公共静态的常量//ctrl+shift+U 大小写转换public static final boolean FLAG = true;public static void main(String[] args) {//final最终的，可以修饰成员变量，局部变量，修饰成员方法，修饰类//final修饰变量，此变量为一个常量，这就是说的自定义常量。常量名使用大写字母来命名//final 修饰方法，此方法不能被子类重写，只能继承。//final 修饰类，此类不能被继承。final int NUM = 100;System.out.println(NUM);System.out.println(MyTest.FLAG);new Zi().show();//final 修饰的是基本数据类型，指的是，值不能再次被改变final double B = 3.2;// B=3.6;//final 修饰引用数据类型，指的是，地址值不能再次被改变。final Zi zi = new Zi();// zi = new Zi();}
}class Fu {public final void show() {System.out.println("fu show");}
}class Zi extends Fu {}//final 修饰类，此类不能被继承。
final class Father {}
//报错，不能继承final修饰的类
/*class Son extends Father{}*/

t.cacheMouse();
}
}

### ### final关键字概述A:为什么会有final​		由于继承中有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法。这时候我们就可以使用关键字：finalB：final概述​	final关键字是最终的意思，可以修饰类，变量，成员方法。### final关键字修饰类，方法以及变量的特点A：final修饰特点​	修饰类：            被修饰的类不能被继承​	修饰方法 ：         修饰的方法不能被重写​	修手机变量:         被修饰的变量不能被重新赋值，因为这个量其实就是一个常量​		fin### final关键字修饰局部变量A：案例​			基本类型，是值不能被改变​			引用类型，是地址值不能被改变

public class MyTest {

public final double A = 3.14;
//公共静态的常量
//ctrl+shift+U 大小写转换
public static final boolean FLAG = true;public static void main(String[] args) {//final最终的，可以修饰成员变量，局部变量，修饰成员方法，修饰类//final修饰变量，此变量为一个常量，这就是说的自定义常量。常量名使用大写字母来命名//final 修饰方法，此方法不能被子类重写，只能继承。//final 修饰类，此类不能被继承。final int NUM = 100;System.out.println(NUM);System.out.println(MyTest.FLAG);new Zi().show();//final 修饰的是基本数据类型，指的是，值不能再次被改变final double B = 3.2;// B=3.6;//final 修饰引用数据类型，指的是，地址值不能再次被改变。final Zi zi = new Zi();// zi = new Zi();}

}

class Fu {
public final void show() {
System.out.println(“fu show”);
}
}

class Zi extends Fu {

}

//final 修饰类，此类不能被继承。
final class Father {

}
//报错，不能继承final修饰的类
/*class Son extends Father{

}*/

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！