final关键字

概述:

继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。可是当子类继承了这些特殊类之后,就可以对其中的方法进行重写,那怎么解决呢?

要解决上述的这些问题,需要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量

特点:

  • final修饰类不可以被继承,但是可以继承其他类
  1. class Yy {}
  2. final class Fu extends Yy{} //可以继承Yy类
  3. class Zi extends Fu{} //不能继承Fu类
  • final修饰的方法不可以被覆盖,但父类中没有被final修饰方法,子类覆盖后可以加final
  1. class Fu {
  2. // final修饰的方法,不可以被覆盖,但可以继承使用
  3. public final void method1(){}
  4. public void method2(){}
  5. }
  6. class Zi extends Fu {
  7. //重写method2方法
  8. public final void method2(){}
  9. }
  • final修饰的变量称为常量,这些变量只能赋值一次。
  1. final int i = 20;
  2. i = 30; //赋值报错,final修饰的变量只能赋值一次
  • 引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。
  1. final Person p = new Person();
  2. Person p2 = new Person();
  3. p = p2; //final修饰的变量p,所记录的地址值不能改变
  4. p.name = "小明";//可以更改p对象中name属性值

p不能为别的对象,而p对象中的name或age属性值可更改。

  • 修饰成员变量,需要在创建对象前赋值,否则报错。(当没有显式赋值时,多个构造方法的均需要为其赋值。)
  1. class Demo {
  2. //直接赋值
  3. final int m = 100;
  4.  
  5. //final修饰的成员变量,需要在创建对象前赋值,否则报错。
  6. final int n;
  7. public Demo(){
  8. //可以在创建对象时所调用的构造方法中,为变量n赋值
  9. n = 2016;
  10. }
  11. }

static关键字

概述:

当在定义类的时候,类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时,这个方法没有访问到对象的特有数据时,方法创建这个对象有些多余。可是不创建对象,方法又调用不了,这时就会想,那么我们能不能不创建对象,就可以调用方法呢?

可以的,我们可以通过static关键字来实现。static它是静态修饰符,一般用来修饰类中的成员。

特点:

  • 被static修饰的成员变量属于类,不属于这个类的某个对象。(也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量)
  1. class Demo {
  2. public static int num = 100;
  3. }
  4.  
  5. class Test {
  6. public static void main(String[] args) {
  7. Demo d1 = new Demo();
  8. Demo d2 = new Demo();
  9. d1.num = 200;
  10. System.out.println(d1.num); //结果为200
  11. System.out.println(d2.num); //结果为200
  12. }
  13. }
  • 被static修饰的成员可以并且建议通过类名直接访问。

访问静态成员的格式:

  1. 类名.静态成员变量名
  2. 类名.静态成员方法名(参数)
  3. 对象名.静态成员变量名 ------不建议使用该方式,会出现警告
  4. 对象名.静态成员方法名(参数) ------不建议使用该方式,会出现警告
  1. class Demo {
  2. //静态成员变量
  3. public static int num = 100;
  4. //静态方法
  5. public static void method(){
  6. System.out.println("静态方法");
  7. }
  8. }
  9. class Test {
  10. public static void main(String[] args) {
  11. System.out.println(Demo.num);
  12. Demo.method();
  13. }
  14. }

static 注意事项

  • 静态内容是优先于对象存在,只能访问静态,不能使用this/super。静态修饰的内容存于静态区。
  1. class Demo {
  2. //成员变量
  3. public int num = 100;
  4. //静态方法
  5. public static void method(){
  6. //this.num; 不能使用this/super。
  7. System.out.println(this.num);
  8. }
  9. }
  • 同一个类中,静态成员只能访问静态成员
  1. class Demo {
  2. //成员变量
  3. public int num = 100;
  4. //静态成员变量
  5. public static int count = 200;
  6. //静态方法
  7. public static void method(){
  8. //System.out.println(num); 静态方法中,只能访问静态成员变量或静态成员方法
  9. System.out.println(count);
  10. }
  11. }
  • main方法为静态方法仅仅为程序执行入口,它不属于任何一个对象,可以定义在任意类中

定义静态常量

开发中,我们想在类中定义一个静态常量,通常使用public static final修饰的变量来完成定义。此时变量名用全部大写,多个单词使用下划线连接。

  1. 定义格式:
  2. public static final 数据类型 变量名 = 值;
  1. class Company {
  2. public static final String COMPANY_NAME = "百度";
  3. public static void method(){
  4. System.out.println("一个静态方法");
  5. }
  6. }

当我们想使用类的静态成员时,不需要创建对象,直接使用类名来访问即可。

  1. System.out.println(Company.COMPANY_NAME); //打印百度
  2. Company.method(); // 调用一个静态方法
  • 注意

接口中的每个成员变量都默认使用public static final修饰。

所有接口中的成员变量已是静态常量,由于接口没有构造方法,所以必须显示赋值。可以直接用接口名访问。

  1. interface Inter {
  2. public static final int COUNT = 100;
  3. }

访问接口中的静态变量

  1. Inter.COUNT

匿名对象

匿名对象的概念:

匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。

如:已经存在的类:

  1. public class Person{
  2. public void eat(){
  3. System.out.println();
  4. }
  5. }

创建一个普通对象

  1. Person p = new Person();

创建一个匿名对象

  1. new Person();

特点:

  • 创建匿名对象直接使用,没有变量名。
  1. new Person().eat() //eat方法被一个没有名字的Person对象调用了。
  • 匿名对象在没有指定其引用变量时,只能使用一次。
  1. new Person().eat(); 创建一个匿名对象,调用eat方法
  2. new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象
  • 匿名对象可以作为方法接收的参数、方法返回值使用
  1. class Demo {
  2. public static Person getPerson(){
  3. //普通方式
  4. //Person p = new Person();
  5. //return p;
  6.  
  7. //匿名对象作为方法返回值
  8. return new Person();
  9. }
  10.  
  11. public static void method(Person p){}
  12. }
  13.  
  14. class Test {
  15. public static void main(String[] args) {
  16. //调用getPerson方法,得到一个Person对象
  17. Person person = Demo.getPerson();
  18.  
  19. //调用method方法
  20. Demo.method(person);
  21. //匿名对象作为方法接收的参数
  22. Demo.method(new Person());
  23. }
  24. }

内部类

  • 什么是内部类

将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。

  • 什么时候使用内部类

在描述事物时,若一个事物内部还包含其他可能包含的事物,比如在描述汽车时,汽车中还包含这发动机,这时发动机就可以使用内部类来描    述。

  1. class 汽车 { //外部类
  2. class 发动机 { //内部类
  3. }
  4. }
  • 内部类的分类

内部类分为成员内部类与局部内部类。

我们定义内部类时,就是一个正常定义类的过程,同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

成员内部类

成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问

  • 定义格式:
  1. class 外部类 {
  2. 修饰符 class 内部类 {
  3. //其他代码
  4. }
  5. }
  • 访问方式:
  1. 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
  • 成员内部类代码:

定义类

  1. class Body {//外部类,身体
  2. private boolean life= true; //生命状态
  3. public class Heart { //内部类,心脏
  4. public void jump() {
  5. System.out.println("心脏噗通噗通的跳")
  6. System.out.println("生命状态" + life); //访问外部类成员变量
  7. }
  8. }
  9. }

访问内部类

  1. public static void main(String[] args) {
  2. //创建内部类对象
  3. Body.Heart bh = new Body().new Heart();
  4. //调用内部类中的方法
  5. bh.jump();
  6. }

局部内部类:

局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问。

  • 定义格式:
  1. class 外部类 {
  2. 修饰符 返回值类型 方法名(参数) {
  3. class 内部类 {
  4. //其他代码
  5. }
  6. }
  7. }
  • 访问方式:

在外部类方法中,创建内部类对象,进行访问

代码:

定义类:

  1. class Party {//外部类,聚会
  2. public void puffBall(){// 吹气球方法
  3. class Ball {// 内部类,气球
  4. public void puff(){
  5. System.out.println("气球膨胀了");
  6. }
  7. }
  8. //创建内部类对象,调用puff方法
  9. new Ball().puff();
  10. }
  11. }

访问内部类:

  1. public static void main(String[] args) {
  2. //创建外部类对象
  3. Party p = new Party();
  4. //调用外部类中的puffBall方法
  5. p.puffBall();
  6. }

  内部类的实际使用——匿名内部类

匿名内部类概念:

内部类是为了应对更为复杂的类间关系。最常用到的内部类就是匿名内部类,它是局部内部类的一种。

定义的匿名内部类有两个含义:

  • 临时定义某一指定类型的子类
  • 定义后即刻创建刚刚定义的这个子类的对象

匿名内部类的作用与格式

作用:匿名内部类是创建某个类型子类对象的快捷方式。

格式:

  1. new 父类或接口(){
  2. //进行方法重写
  3. };
  1. //已经存在的父类:
  2. public abstract class Person{
  3. public abstract void eat();
  4. }
  5. //定义并创建该父类的子类对象,并用多态的方式赋值给父类引用变量
  6. Person p = new Person(){
  7. public void eat() {
  8. System.out.println(“我吃了”);
  9. }
  10. };
  11. //调用eat方法
  12. p.eat();

使用匿名对象的方式,将定义子类与创建子类对象两个步骤由一个格式一次完成,。虽然是两个步骤,但是两个步骤是连在一起完成的。

匿名内部类如果不定义变量引用,则也是匿名对象。代码如下:

  1. new Person(){
  2. public void eat() {
  3. System.out.println(“我吃了”);
  4. }
  5. }.eat();

访问修饰符

在Java中提供了四种访问权限,使用不同的访问权限时,被修饰的内容会有不同的访问权限,以下表来说明不同权限的访问能力:

public

protected

default

private

同一类中

同一包中(子类与无关类)

不同包的子类

不同包中的无关类

归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问

  • 要想仅能在本类中访问使用private修饰;
  • 要想本包中的类都可以访问不加修饰符即可;
  • 要想本包中的类与其他包中的子类可以访问使用protected修饰
  • 要想所有包中的所有类都可以访问使用public修饰。
  • 注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

代码块

局部代码块

局部代码块是定义在方法或语句中

特点:

  • 以”{}”划定的代码区域,此时只需要关注作用域的不同即可
  • 方法和类都是以代码块的方式划定边界的
  1. class Demo{
  2. public static void main(String[] args) {
  3. {
  4. int x = 1;
  5. System.out.println("普通代码块" + x);
  6. }
  7. int x = 99;
  8. System.out.println("代码块之外" + x);
  9. }
  10. }

结果:

普通代码块1

代码块之外99

构造代码块

构造代码块是定义在类中成员位置的代码块

特点:

  • 优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作
  • 每创建一个对象均会执行一次构造代码块。
  1. public class Person {
  2. private String name;
  3. private int age;
  4.  
  5. //构造代码块
  6. {
  7. System.out.println("构造代码块执行了");
  8. }
  9. Person(){
  10. System.out.println("Person无参数的构造函数执行");
  11. }
  12. Person(int age){
  13. this.age = age;
  14. System.out.println("Person(age)参数的构造函数执行");
  15. }
  16. }
  17. class PersonDemo{
  18. public static void main(String[] args) {
  19. Person p = new Person();
  20. Person p1 = new Person(23);
  21. }
  22. }

静态代码块

静态代码块是定义在成员位置,使用static修饰的代码块。

特点:

  • 它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。
  • 该类不管创建多少对象,静态代码块只执行一次。
  • 可用于给静态变量赋值,用来给类进行初始化。
  1. public class Person {
  2. private String name;
  3. private int age;
  4. //静态代码块
  5. static{
  6. System.out.println("静态代码块执行了");
  7. }
  8. }

Java_关键字、匿名对象、内部类、访问修饰符、代码块的更多相关文章

  1. Java—匿名对象/内部类/访问修饰符/代码块

    匿名对象 匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量. //创建一个普通对象 Person p = new Person(); //创建一个匿名对象 new Pers ...

  2. -1-2 java 面向对象基本概念 封装继承多态 变量 this super static 静态变量 匿名对象 值传递 初始化过程 代码块 final关键字 抽象类 接口 区别 多态 包 访问权限 内部类 匿名内部类 == 与 equal

    java是纯粹的面向对象的语言 也就是万事万物皆是对象 程序是对象的集合,他们通过发送消息来相互通信 每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象 每个对象都有它的类型  也就是 ...

  3. Java面向对象(概述,构造函数,类与对象的关系,this关键字,成员、局部),匿名对象的调用,构造代码块(5)

    Java面向对象(概述,构造函数,类与对象的关系,this关键字,成员.局部),匿名对象的帝爱用,构造代码块(5)

  4. Java学习笔记:04面向对象-内部类_访问修饰符_final

    04面向对象-内部类/访问修饰符/final 1.static的介绍 static:关键字,静态的 static的作用是用来修饰类中的成员 2.访问一个类中的某一个成员变量 方法一: _1.创建对象 ...

  5. C#关键字:访问修饰符

    一.访问修饰符 访问修饰符有public.private.protected.internal和protected internal.它们是修饰在类型(类.接口.委托.结构和枚举)和类型成员(字段.属 ...

  6. 【转】C# 中访问修饰符

    用通过代码:  类内部 using System;class Mod{    void defaultMethod()    {        Console.WriteLine("this ...

  7. 访问修饰符protected

    protected(C# 参考) protected 关键字是一个成员访问修饰符. 受保护成员在其所在的类中可由派生类实例访问. 示例只有在通过派生类访问时,基类的受保护成员在派生类中才是可访问的. ...

  8. 访问修饰符private

    private(C# 参考) private 关键字是一个成员访问修饰符. 私有访问是允许的最低访问级别. 私有成员只有在声明它们的类和结构体中才是可访问的,如下例所示: class Employee ...

  9. this、访问修饰符——Java笔记(五)

    this         表示当前对象         谁调用方法谁就是当前对象 用static修饰的代码块里面不能使用this 方法里面有一个和字段同名的局部变量时,不能省略this   this还 ...

随机推荐

  1. Bootstrap 文件上传插件 FileInput的使用问题

    : 在使用bootstrap的文件上传插件fileinput http://plugins.krajee.com/file-input的预览功能时,删除预览图片在 bootstrap 模态框中没有用, ...

  2. gulpfile.js文档

    gulp watch 实现监听不仅需要package.json文档,还需要gulpfile.js文档.否则无法实现. 1.gulp的安装 1.1 首先必须先安装node.js.这个可以参考之前的博客& ...

  3. Linux高级编程--03.make和makfile

    Makefile语法基础 在Linux下,自动化编译工具是通过make命令来完成的(一些工具厂商也提供了它们自己的make命令,如gmake等),make命令的基本格式如下: make [-f mak ...

  4. spring boot(二):注解大全

    spring boot注解 @Autowired 注解的意思就是,当Spring发现@Autowired注解时,将自动在代码上下文中找到和其匹配(默认是类型匹配)的Bean,并自动注入到相应的地方去. ...

  5. 【BZOJ】2565: 最长双回文串

    [题意]给定小写字母字符串s,求最长的 [ 可以分成左右两个回文串的 ] 子串,n<=10^5. [算法]回文树 [题解]对于每个字符x,处理出以x结尾的最长回文串,以x开头的最长回文串,然后枚 ...

  6. cookie 跨域的问题

    今天研究一天发现cookie无法设置除当前域名或者其父域名之外的其他domain. 这个是浏览器出于对cookie的保护造成的,也就是cookie无法跨域设置. 对于子域名也有如下规则,当前域名只能设 ...

  7. pytesser模块WindowsError错误解决方法

    在使用pytesser做图片文字识别时遇到 WindowsError: [Error 2] 错误,报错内容如下: Traceback (most recent call last): File &qu ...

  8. Minimum Palindromic Factorization(最少回文串分割)

    Minimum Palindromic Factorization(最少回文串分割) 以下内容大部分(可以说除了关于回文树的部分)来自论文A Subquadratic Algorithm for Mi ...

  9. C/C++——[05] 函数

    函数是 C/C++语言中的一种程序组件单位.一个函数通常代表了一种数据处理的功能,由函数体和函数原型两部分组成.函数原型为这个数据处理功能指定一个标识符号(函数的名称).说明被处理数据的组成及其类型. ...

  10. scikit-learn模块学习笔记(数据预处理模块preprocessing)

    本篇文章主要简单介绍sklearn中的数据预处理preprocessing模块,它可以对数据进行标准化.preprocessing 模块提供了数据预处理函数和预处理类,预处理类主要是为了方便添加到pi ...