1.final变量 final关键字可用于变量声明，一旦改变了被设定，就不可以再改变该变量的值。通常，由final定义的变量为常量。 final double PI = 3.14； final Test test = new Test(); final int[] a ={1,2,3,4,5,6}; 一旦一个对象引用被修饰为final 2.final方法 final的方法不能被重写。 一个定义为private的方法隐式被指定为final类型。 父类中被定义为private final的方法不可以被子类同名方法覆盖，而是生成新方法。 3.final类 定义为final的类不能被继承，如果将某个类设置为final形式，则类中的所有方法都被隐式的设置为final形式，但是final类中的成员变量可以被定义为final或者非final形式
当然要利用下metaclass做手脚啦 class Final(type): def __new__(cls, name, bases, classdict): for b in bases: if isinstance(b, Final): raise TypeError("type '{0}' is Final type dict(classdict)) class Hi(object): def hi(self): print("hi") class SubHi(Hi, metaclass=Final ): pass # 这个没问题 s = SubHi() s.hi() # TypeError: type 'SubHi' is Final type class SubHi2(SubHi):
领8888元新春采购礼包，抢爆款2核2G云服务器95元/年起，个人开发者加享折上折
String类为什么是final的？ **被final修饰的类不能被继承，即它不能拥有自己的子类; 被final修饰的方法不能被重写; final修饰的变量，无论是类属性、对象属性、形参还是局部变量，都需要进行初始化操作。 类属性可以理解为一个将一个类作为另一个类的属性 ? ? 主要是为了”安全性“和”效率“的缘故，因为： 1、由于String类不能被继承，所以就不会没修改，这就避免了因为继承引起的安全隐患； 2、String类在程序中出现的频率比较高，如果为了避免安全隐患， 在它每次出现时都用final来修饰，这无疑会降低程序的执行效率，所以干脆直接将其设为final一提高效率；
抽象类： 基于继承 抽象类和抽象方法的定义 父类的意义： 把子类共有的属性，抽取出来，达到代码的重用 抽象类不可被实例化 使用抽象类，限制实例化（只有派生类能实例化，父类不能实例化） 关键字：abstract // 3、创建企鹅对象pgn并输出信息 Penguin pgn = new Penguin("楠楠", "Q妹"); pgn.print(); } } final 用法： final修饰属性，方法和类 可以修饰类：最终版的类 不希望再被其他类继承 public finla class text{} 可以修饰方法： 方法不希望被重写 public class text{ public final void text1(){} } 可以修饰变量：（常量）最终版的属性值 属性不希望被修改 public class text{ public final int a; } 总结： 抽象类和抽象方法: 抽象类不能被实例化‘ 可以有0~多个抽象方法 非抽象类必须重写父类的所有抽象方法 final修饰符:
第十七章 类关键字 - DependsOn指定此类应在编译器使其他(指定的)类可运行后编译。 是下列之一:类名[ DependsOn = MyApp.Class1 ]用逗号分隔的类名列表，用括号括起来。 第十九章 类关键字 - Final指定此类是否是最终类(不能有子类)。 用法要指定一个类是最终类，请使用以下语法:Class MyApp.Exam As %Persistent [ Final ] { //class members }否则，省略此关键字或将单词Not放在关键字的前面 详情如果一个类是最终类，它就不能有子类。此外，如果一个类是最终类，类编译器会利用某些代码生成优化(与最终类的实例不能多形态使用的事实有关)。默认如果省略此关键字，类定义不是最终的。
为了不让创建对象 C:abstract不能和哪些关键字共存 a:final 冲突 b:private 冲突 c:static 无意义 /* 一个类如果没有抽象方法，可不可以定义为抽象类? private 冲突 final 冲突 static 无意义 */ abstract class Fu { //public abstract void show(); //非法的修饰符组合: abstract和private //private abstract void show(); //非法的修饰符组合 //final abstract void show(); //非法的修饰符组合 默认修饰符：public static final 建议：自己手动给出。 构造方法：接口没有构造方法。 成员方法：只能是抽象方法。 */ interface Inter { public int num = 10; public final int num2 = 20; public static final int num3
String类为什么是final的？ 被final修饰的类不能被继承，即它不能拥有自己的子类；被final修饰的方法不能被重写；final修饰的变量，无论是类属性、对象属性、形参还是局部变量，都需要进行初始化操作。 类属性可以理解为一个将一个类作为另一个类的属性。 主要是为了安全性和效率的缘故，因为： 1、由于String类不能被继承，所以就不会没修改，这就避免了因为继承引起的安全隐患； 2、String类在程序中出现的频率比较高，如果为了避免安全隐患，在它每次出现时都用 final来修饰，这无疑会降低程序的执行效率，所以干脆直接将其设为final一提高效率；
1:final关键字(掌握) (1)是最终的意思，可以修饰类，方法，变量。 (2)特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量。 /* final可以修饰类，方法，变量 特点： final可以修饰类，该类不能被继承。 final可以修饰方法，该方法不能被重写。 常量： A:字面值常量 "hello",10,true B:自定义常量 final int x = 10; */ //final class Fu //无法从最终Fu进行继承 class Fu { public int num = 10; public final int num2 = 20; /* public final void show() { } */ } class Zi 所以，父类的功能，就会被子类给覆盖调。 有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。 这个时候，针对这种情况，Java就提供了一个关键字：final final:最终的意思。
类其中的变量为final时的用法： 类当中final变量没有初始缺省值，必须在构造函数中赋值或直接当时赋值。否则报错。 public class Test { final int i; Test(){ i=3; } public static void main(final Test t=new Test(); System.out.println("i = " + t.i); } } 或者 public class Test { final int i=9; public static void main(final String[] args) { Test t=new Test(); System.out.println
final修饰类：表示该类不能被继承 final修饰属性：表示该属性必须被赋值一次 final修饰方法：表示该方法可以被子类继承，但是不能被子类重写 1 class A{ 2 final public int i;//报错 3 //被final修饰的变量叫做常变量(固定不变)，必须被赋值且只能赋值一次，哪怕第二次赋值跟第一个赋值一样也不行 4 //不能放在普通方法里赋值，因为可能不会调用这个普通方法
final修饰的类不可以被继承，但可以继承其他的类。 final修饰的方法，子类可以继承但是不能重写。 子类重写父类的非final方法可以加上final。 被final修饰的基本数据类型或者String类型的变量可以看作是常量，赋值后不能改变。 被final修饰的引用数据类型变量的引用内存地址值不能改变，可以改变引用数据类型变量的属性值。 被final修饰的普通成员变量必须在对象创建完成前进行赋值，可以直接赋值，如果没有直接赋值则需要用构造方法进行赋值，如果有多个构造方法则多个构造方法都要为其赋值，但是不能用set方法赋值。 被final修饰的静态成员变量必须要直接赋值或者静态代码块赋值，否则编译不通过。 final修饰的成员变量会在编译阶段赋默认值，final固定的是成员变量的手动赋值不是内存中的默认值。 Q.E.D.
先准备几个类，方便后面讲解： public final class FinalSampleUtils { public static String foo() { return "aaa"; } public static String bar(String a) { return "bar:" + a; } } 这是一个final类 public class NewObject { public String haha() { return "haha"; } } 这是一个平淡无奇的类，没啥好说的。 System.out.println("hello2:" + bar); System.out.println("h:" + obj.haha()); } } 这是一个普通的@Service实现类， 里面用到的NewObject，并不是@Autowired之类由Spring注入的，而是自己new的 2. helloWorld里，使用了final类的静态方法，以及obj的普通方法。
final 修饰的类是不被能继承的，所以 final 修饰的类是不能被篡改的。 翻开JDK源码，java.lang.String类起手前三行，是这样写的： public final class String implements java.io.Serializable, Comparable 而且用final关键字修饰.*/ private final char value[]; ... ... } String类的主力成员字段value是个char[ ]数组，而且是用 String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。 为final类型时： package test; public class 为什么String要设计成不可变类 { public static void main(String[] args
翻开JDK源码，java.lang.String类起手前三行，是这样写的： public final class String implements java.io.Serializable, Comparable 而且用final关键字修饰.*/private final char value[]; ... ...} 首先String类是用final关键字修饰，这说明String不可继承。 再看下面，String类的主力成员字段value是个char[ ]数组，而且是用final修饰的。final修饰的字段创建以后就不可改变。 有的人以为故事就这样完了，其实没有。 String类里的value用final修饰，只是说stack里的这个叫value的引用地址不可变。没有说堆里array本身数据不可变。 看下面这个例子， final int[] value={1,2,3}int[] another={4,5,6};value=another; //编译器报错，final不可变 value用final
一般子类被称为派生类,父类称为基类(super) extends需要注意的地方： java不允许多重继承(一个类只能继承一个父类,不能继承多个父类)、 派生类会继承基类所有属性和方法,但不能直接访问基类的 3.final关键字 在java中,final被称为终结器, final可以修饰变量,方法和类. 3.1 final修饰类 当final修饰类时,则表示该类为最终的,也就是说该类不能再有子类了,示例如下 : final class A { // 修饰该类不能有子类 } class B extends A { // 错误的继承 } 3.2 final 修饰方法 当在某个类的方法前面定义final时,则表示该方法不允许在子类里进行方法覆写(可以实现方法重载) 示例如下: class A { public final void fun( 修饰变量 当final修饰变量时,则表示该变量为常量(类似C++中const).示例如下: public static final String LICENSE = "GPL";
final声明变量 final声明变量可以保证在构造器函数返回之前，这个变量的值已经被设置。详细可以看final声明的重排序规则。 final不能用于修饰构造方法。使用final方法的原因有二： 第一、把方法锁定，防止任何继承类修改它的意义和实现。 第二、高效。 final声明类 final声明的类不可以被继承，final类中的方法默认是final的。但是成员变量却不一定是final的，必须额外给成员变量声明为final。 注意：一个类不能同时被abstract和final声明。 在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会被扩展，那么就设计为final类。 比如Java中有许多类是final的，譬如String, Interger以及其他包装类。
一、final关键字 C++新标准规定：如果我们定义的类不希望被其他类继承，那么可以在类名后加一个final关键字 但是final类仍然可以继承其他类。 实际上C++11的关键字final有两个用途。第一，它阻止了从类继承；第二，阻止一个虚函数的重载。 class C:public B {}; //错误 某些实现系统服务、基础功能和加密等的类通常是不允许有子类的；实现者不想客户端从这些类派生新类而修改他们。 如果一个派生类试图重载一个final函数，编译器就会报错： struct A { virtual void func() const; }; struct B: A { void func() const 没关系，一旦一个虚函数被声明为final，派生类不能再重载它。
--------------------------------------- 1:final关键字可以干什么？有什么特点？ 最终的意思。可以修饰类，方法，变量。 --------------------------------------- 2:final关键字的面试题？ A:修饰局部变量 基本类型：值不能改变。 B:抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。 C:抽象类不能被实例化。 D:抽象类的子类： a:是抽象类。 如果一个类中有了一个抽象方法，那么这个类必须声明为抽象类，否则编译通不过。 意义：就是不让其他类创建本类对象，而是交给子类完成，防止乱用。 B:abstract不能和哪些关键字共存： final 冲突 private 冲突 static 无意义 --------------------------
定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类。 可以自己试试，一般的编译器也会提示错误的。
我们先看看抽象类、接口各自的特性。 抽象类 抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。 它根本不存在方法的实现 实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。 子类使用关键字implements来实现接口。 它需要提供接口中所有声明的方法的实现 构造器 抽象类可以有构造器 接口不能有构造器 与正常Java类的区别 除了你不能实例化抽象类之外，它和普通Java类没有任何区别 接口是完全不同的类型 访问修饰符 什么时候使用抽象类和接口 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。 如果你想实现多重继承，那么你必须使用接口。 由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。 如果基本功能在不断改变，那么就需要使用抽象类。
腾讯智慧建筑管理平台（微瓴）是深度适配智慧建筑场景的物联网类操作系统，针对于建筑内的硬件、应用等资源，提供物联、管理与数字服务，赋予建筑综合协同的智慧能力，并为建筑管理运营者与建筑业主方提供安全、高效、便利的建筑综合管理运营系统……
扫码关注腾讯云开发者
领取腾讯云代金券
云服务器
网站备案
对象存储
云直播
实时音视频
