final关键字+static关键字+匿名对象

接上文，我们学习完构造方法+this+super关键字后，发现有时在代码中出现的final和static关键字非常眼熟，但是他们是什么意思呢？

首先，我们需要从封装、继承、多态开始想起，继承的主要意义在于子类完全继承父类中的属性和方法，但有的方法或属性我们不想被继承怎么办？删除是不可能被删除的，只能靠阻止被继承来解决这个问题，那么就用到了final关键字了，它作为存在于方法中的修饰符，可以修饰类，类的成员变量，方法，局部变量，高亮，它不能修饰构造方法，为啥呢？因为构造方法没有修饰符和返回值。一旦静态修饰后，无法被调取或者继承。构造方法无法修改。

初步了解final后我们可以深入了解它。

1、final修饰的类不能被继承，但能继承其他的类

public class fu（）

public final class zi extends fu（）{}//可继承fu，不能被下面重写

2、final修饰的方法不能被重写，但可以继承使用

class fu{

public final void cat（）{}

public void dog（）{}

}

//子类继承

public void eat extends fu（）{

　　public dog（）{}//可继承普通方法

　　　}

3、final修饰的量为常量，一次修改后面不可修改

 final int i=10；//变成了常量，后面不可修改

4、final修饰的成员变量和需要在创建对象前赋值

public class fu{

　　final int a=1；//直接赋值

　　final int b；//如果没有赋值怎么办？用专门用来赋值的构造方法

public zi(){

　　b=5;

system.out.in(b);//5

　　}

}

5.final修饰的引用数据类型不能更改地址，但可以更改地址内的属性，如

final student s=new student(); s是存储的地址

student s1=new student();

s=s1;//地址没有变化

s.name="李四";

二、static静态修饰符

它的出现是为了解决我们用对象名.方法名（）调取不到类里特定的数据，用静态修饰符来实现。

它的位置尤其重要，一般的关键字都跟随方法进栈，但它却是随着main方法直接进堆，也就是说当我们程序还没有在栈运行的时候，静态修饰符已经通过构造方法赋上初值了。

下面我们举例和画一个static内存图来详细了解下它的区别。

package com.oracle.demo01;
public class Student {
    private String name;
    //static静态变成类的
    //静态不能访问非静态，因为非静态不在方法与数据共享区
    //尽量用类名方式访问
    public  static  String schoolName;
    public static final String ClASS_NAME="0611";
    //构造函数
    public Student(String name, String schoolName) {
        super();
        this.name = name;
        //本类对象不合适
        //this.schoolName = schoolName;
    }
    //封装
    public String getName() {
        return name;
    }
    /*public void setName(String name) {
        this.name = name;
    }*/
    public String getSchoolName() {
        return schoolName;
    }
    /*public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }*/
    public static void sho(){
        System.out.println("我是一个静态方法");
    }
}

 

package com.oracle.demo01;

public class Demo01 {
public static void main(String[] args) {
    //构造函数的调取
    Student.schoolName="人民大学";//直接给静态赋值人民大学，后面输出只有人民大学了。
    Student stu=new Student("张三","清华大学");
    Student stu1=new Student("李四","北京大学");
    System.out.println(stu.getName()+"..."+stu.getSchoolName());
    System.out.println(stu1.getName()+"..."+stu1.getSchoolName());
    //对象名.方法名，调取普通方法
    Student.sho();
    //打印静态常量

 　　//静态调取==类名.静态（）
    System.out.println(Student.ClASS_NAME);后面只能输出0611
    System.out.println(Math.PI);
    }
}

静态父类
package com.oracle.demo01;
public class Fu {
    static int i=1;
    public static void show(){
        System.out.println("这是父类的方法");
    }
}
继承子类
public class Zi extends Fu{
    int i=2;
    //多态运行看右边
    public static void show(){
        System.out.println("这是子类的方法");
    }
测试类：
public static void main(String[] args) {
        Fu f=new Zi();
        System.out.println(f.i);
        //多态方法，有静态情况下，编译运行都看左边
        //成员变量，编译运行全是左边父类
        f.show();
    }

 

 

 

 

 

三、匿名对象

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

创建一个普通对象

Person p = new Person();

创建一个匿名对象

new Person();

匿名对象的特点：

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

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

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

 

二期项目，通过匿名方法调取菜单来连接起后续的操作流程
public class Test1 {
    public static void main(String[] args) {
        //匿名对象掉方法
    new MessAgezong().MainMenu();
        //new MainView_Boos().MainMenu();
    }

 

 

 

new Person().eat(); 创建一个匿名对象，调用eat方法

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

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

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());

 

　　}

 

}