Java基础语法（十三）

最新推荐文章于 2020-12-21 22:27:54 发布

汪喆_Jack

最新推荐文章于 2020-12-21 22:27:54 发布

阅读量481

点赞数 5

分类专栏： JAVA相关文章标签： Java final static 内部类包

本文链接：https://blog.csdn.net/qq_34829447/article/details/82056332

版权

JAVA相关专栏收录该内容

57 篇文章 15 订阅

订阅专栏

一.final关键字

1.final概述

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

需要使用到一个关键字final，final的意思为最终，不可变。
final是个修饰符，它可以用来修饰类，类的成员方法和成员变量，以及局部变量。

2.final修饰类

final修饰类不可以被继承，但是可以继承其他类

实例代码

class Yy {}
final class Fu extends Yy{} //可以继承Yy类
class Zi extends Fu{} //不能继承Fu类

3.final修饰方法

final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final
final修饰的方法可以继承，不能重写

实例代码

class Fu {
  // final修饰的方法，不可以被覆盖，但可以继承使用
  public final void method1(){}
  public void method2(){}
}
class Zi extends Fu {
  //重写method2方法
  public final void method2(){}
}

4.final修饰局部变量

修饰基本数据类型变量
- final修饰的变量称为常量，这些变量只能赋值一次[局部变量]
- 实例代码
```
final int i = 20;
i = 30; //赋值报错，final修饰的变量只能赋值一次
```

修饰引用数据类型

引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改
实例代码

final Person p = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = "小明";//可以更改p对象中name属性值
p不能为别的对象，而p对象中的name或age属性值可更改。

5.final修饰成员变量

修饰成员变量：需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值)【需要在定义时直接=赋值；或采用构造方法赋值】

实例代码

class Demo {
  //直接赋值
  final int m = 100;
  //final修饰的成员变量，需要在创建对象前赋值，否则报错。
  final int n; 
  public Demo(){
      //可以在创建对象时所调用的构造方法中，为变量n赋值
      n = 2016;
  }
}

二.static关键字

1.static概念

当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

2.static修饰的对象特有数据

被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

实例代码

class Demo {
  public static int num = 100;
}
class Test {
  public static void main(String[] args) {
      Demo d1 = new Demo();
      Demo d2 = new Demo();
      d1.num = 200;
      System.out.println(d1.num); //结果为200
      System.out.println(d2.num); //结果为200
  }
}

3.static的内存图

这里写图片描述

4.static注意事项（静态不能调用非静态）

被static修饰的成员可以并且建议通过类名直接访问
静态中不能有this和super，因为静态是属于类的，而不是属于对象的
同一个类中，静态成员只能访问静态成员
访问静态成员的格式
- 类名.静态成员变量名
- 类名.静态成员方法名(参数)
- 对象名.静态成员变量名[不建议使用该方式，会出现警告]
- 对象名.静态成员方法名(参数)[不建议使用该方式，会出现警告]

实例代码

class Demo {
  //静态成员变量
  public static int num = 100;
  //静态方法
  public static void method(){
      System.out.println("静态方法");
  }
}
class Test {
  public static void main(String[] args) {
      System.out.println(Demo.num);
      Demo.method();
  }
}

5.static静态的使用场景

static可以修饰成员变量和成员方法
什么时候使用static修饰成员变量？

加static修饰成员的时候，这个成员会被类的所有对象所共享。一般我们把共性数据定义为静态的变量
什么时候使用static修饰成员方法？

静态的方法只能访问静态的成员，如果静态方法中引用到了静态的其他成员，那么这个方法需要声明为静态的方法

6.对象中的静态调用

对象的静态调用

在多态中，非静态编译看父类，运行看子类，父类没有编译失败。但多态中的静态方法,编译看父类,运行仍然看父类。因为静态和对象没有关系，属于静态绑定。【即调用方法输出的是父类的方法】

实例代码

public class Test{
  public static void main(String[] args){
      Fu f = new Zi();
      f.show();   //父类的引用和父类的方法绑定,和对象无关,不会在运行时动态的执行子类特有的方法。
  }
}

7.定义静态常量

定时静态常量格式

public static final 数据类型 变量名 = 值;

实例代码

class Company {
  public static final String COMPANY_NAME = "传智播客";
  public static void method(){
      System.out.println("一个静态方法");
  }
}
//当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。
System.out.println(Company.COMPANY_NAME); //打印传智播客
Company.method(); // 调用一个静态方法

注意
- 接口中的每个成员变量都默认使用public static final修饰
- 所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问
- 实例代码
```
interface Inter {
        public static final int COUNT = 100;
    }
//访问接口中的静态变量
Inter.COUNT
```

三.匿名对象

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

创建匿名对象格式

//创建一个匿名对象
new Person();

匿名对象的特点

创建匿名对象直接使用，没有变量名

new Person().eat()  //eat方法被一个没有名字的Person对象调用了。

匿名对象在没有指定其引用变量时，只能使用一次

new Person().eat(); //创建一个匿名对象，调用eat方法
new Person().eat(); //想再次调用eat方法，重新创建了一个匿名对象

匿名对象可以作为方法接收的参数、方法返回值使用

class Demo {
    public static Person getPerson(){
        //普通方式
        //Person p = new Person();  
        //return p;
        //匿名对象作为方法返回值
        return new Person(); 
    }
    public static void method(Person p){}
}
class Test {
    public static void main(String[] args) {
        //调用getPerson方法，得到一个Person对象
        Person person = Demo.getPerson();
        //调用method方法
        Demo.method(person);
        //匿名对象作为方法接收的参数
        Demo.method(new Person());
    }
}

四.内部类

1.内部类的概述

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

2.什么时候使用内部类

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

实例代码

class 汽车 { //外部类
  class 发动机 { //内部类
  }
}

3.内部类的分类

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

4.成员内部类的调用格式

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

定义格式

class 外部类 { 
  修饰符 class 内部类 {
      //其他代码
  }
}

访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

调用规则
- 内部类可以使用外部类成员，包括私有
- 外部类要使用内部类成员需要建立内部类对象

实例代码

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

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

5.局部内部类

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

定义格式

class 外部类 { 
  修饰符 返回值类型 方法名(参数) {
      class 内部类 {
          //其他代码
      }
  }
}

访问方式

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

实例代码

class Party {//外部类，聚会
  public void puffBall(){// 吹气球方法
      class Ball {// 内部类，气球
          public void puff(){
              System.out.println("气球膨胀了");
          }
      }
      //创建内部类对象，调用puff方法
      new Ball().puff();
  }
}
//访问内部类
public static void main(String[] args) {  
//创建外部类对象
Party p = new Party();
//调用外部类中的puffBall方法
p.puffBall();
}

6.匿名内部类

概述

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

匿名内部类的本质是一个实现了接口或继承了某个类的子类匿名对象

格式

new 父类或接口(){
//进行方法重写
};

实例代码1

public interface Smoking {
public abstract void smoking();
}
/*
 *  实现类,实现接口 重写接口抽象方法,创建实现类对象
 *  class XXX implements Smoking{
 *      public void smoking(){
 *      
 *      }
 *  }
 *  XXX x = new XXX();
 *  x.smoking(); 
 *  Smoking s = new XXX();
 *  s.smoking();
 *  
 *  匿名内部类,简化问题:  定义实现类,重写方法,建立实现类对象,合为一步完成
 */

//测试类:
public class Test {
public static void main(String[] args) {
    //使用匿名内部类
    /*
     *  定义实现类,重写方法,创建实现类对象,一步搞定
     *  格式:
     *    new 接口或者父类(){
     *       重写抽象方法
     *    };
     *    从 new开始,到分号结束
     *    创建了接口的实现类的对象
     */
    new Smoking(){
        public void smoking(){
            System.out.println("人在吸烟");
        }
    }.smoking();
}
}

实例代码2

public abstract class Animal {
  public abstract void eat();
  public abstract void sleep();
}
//测试代码
/*
*    new Animal(){
        public void eat(){
            System.out.println("在吃饭");
        } 
        public void sleep(){
            System.out.println("在睡觉");
        }
     };
以上代码,就是Animal的子类的对象
多态性, 父类引用 = 子类的对象

*/
public class Test2 {
public static void main(String[] args) {
    Animal a= new Animal(){
        public void eat(){
            System.out.println("在吃饭");
        } 
        public void sleep(){
            System.out.println("在睡觉");
        }
     };
     a.eat();
     a.sleep();
}
}

五.包的声明和访问

1.包的概念

java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

2.声明格式

package 包名.包名.包名…;

注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）

3.包的访问

在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。
类的简化访问
- 当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。

4.导入包

格式：import 包名.类名;

5.权限修饰符

Java中提供了四种访问权限，不同的权限有不同的访问能力

区域	public	protected	default	private
同一类中	√	√	√	√
同一包中（子类与无关类）	√	√	√
不同包中的子类	√	√
不同包中的无关类	√

* 结论

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

七.代码块

1.概述

程序中用大括号括起来的代码叫代码块

2.代码块分类

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

特点：以”{}”划定的代码区域，此时只需要关注作用域的不同即可。方法和类都是以代码块的方式划定边界的。
作用：可以限定变量的生命周期
实例代码

class Demo{
    public static void main(String[] args)  {
        {
            int x = 1;
            System.out.println("普通代码块" + x);
        }
        int x = 99;
        System.out.println("代码块之外" + x);
    }
}

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

特点：优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作，每创建一个对象均会执行一次构造代码块
作用：用来给对象中的成员初始化赋值
实例代码

public class Person {
    private String name;
    private int age;
    //构造代码块
    {
        System.out.println("构造代码块执行了");
    }
    Person(){
        System.out.println("Person无参数的构造函数执行");
    }
    Person(int age){
        this.age = age;
        System.out.println("Person（age）参数的构造函数执行");
    }
}
class PersonDemo{
    public static void main(String[] args)  {
        Person p = new Person();
        Person p1 = new Person(23);
    }
}

静态代码块：定义在成员位置，使用static修饰的代码块
- 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。该类不管创建多少对象，静态代码块只执行一次。可用于给静态变量赋值，用来给类进行初始化。
- 作用：用来给类的静态成员初始化赋值
- 实例代码
```
public class Person {
    private String name;
    private int age;
    //静态代码块
    static{
        System.out.println("静态代码块执行了");
    }
}   
```
同步代码块

汪喆_Jack

关注

5
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Java基础语法（十三）

一.final关键字1.final概述继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员方法和成员变量...
复制链接

扫一扫

专栏目录