• 动态绑定,多态,static


    1:下面程序的输出结果为:

    class base2{
        static{
            System.out.println("static base2");
        }
    }
    public class test extends Base{
     
        static{
            System.out.println("test static");
        }
         
        {
            System.out.println("1");
        }
        public test(){
            System.out.println("test constructor");
        }
         
        public static void main(String[] args) {
            new test();
        }
    }
     
    class Base{
         
        static{
            System.out.println("base static");
        }
        {
            System.out.println("2");
        }
        public Base(){
            System.out.println("base constructor");
        }
    }

    answer:

    base static
    test static
    2
    base constructor
    1
    test constructor

    2:下面程序的输出结果为:

    public class Test {
        public static void main(String[] args)  {
            Shape shape = new Circle();
            System.out.println(shape.name);
            shape.printType();
            shape.printName();
        }
    }
     
    class Shape {
        public String name = "shape";
         
        public Shape(){
            System.out.println("shape constructor");
        }
         
        public void printType() {
            System.out.println("this is shape");
        }
         
        public static void printName() {
            System.out.println("shape");
        }
    }
     
    class Circle extends Shape {
        public String name = "circle";
         
        public Circle() {
            System.out.println("circle constructor");
        }
         
        public void printType() {
            System.out.println("this is circle");
        }
         
        public static void printName() {
            System.out.println("circle");
        }
    }

    answer:

    shape constructor
    circle constructor
    shape
    this is circle
    shape

    将:

    Shape shape = new Circle();

    改为:
    Circle shape = new Circle();
    public class Test {
        public static void main(String[] args)  {
            //Shape shape = new Circle();
               Circle shape = new Circle();
            System.out.println(shape.name);
            shape.printType();
            shape.printName();
        }
    }
     
    class Shape {
        public String name = "shape";
         
        public Shape(){
            System.out.println("shape constructor");
        }
         
        public void printType() {
            System.out.println("this is shape");
        }
         
        public static void printName() {
            System.out.println("shape");
        }
    }
     
    class Circle extends Shape {
        public String name = "circle";
         
        public Circle() {
            System.out.println("circle constructor");
        }
         
        public void printType() {
            System.out.println("this is circle");
        }
         
        public static void printName() {
            System.out.println("circle");
        }
    }
    答案为:
    shape constructor
    circle constructor
    circle 
    this is circle
    circle  

    “static方法就是没有this的方法。在static方法内部不能调用非静态方法,反过来是可以的。而且可以在没有创建任何对象的前提下,
    仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。
    static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。
    并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
    但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法/变量的。举个简单的例子:

    在Java中,提供了四种访问权限控制:默认访问权限(包访问权限),public,private以及protected。
    注意,上述四种访问权限,只有默认访问权限和public能够用来修饰类。修饰类的变量和方法四种权限都可以。(本处所说的类针对的是外部类,不包括内部类)

    static修饰变量是可以改变值的

    final变量不能改变 

    静态变量,静态代码块,类加载的时候执行

    最后给出执行步骤:

    1、父类静态变量和静态代码块(先声明的先执行);

    2、子类静态变量和静态代码块(先声明的先执行);

    3、父类的变量和代码块(先声明的先执行);

    4、父类的构造函数;

    5、子类的变量和代码块(先声明的先执行);

    6、子类的构造函数。

    java当中的方法只有final,static,private和构造方法是前期绑定

    关于final,static,private和构造方法是前期绑定的理解
    对于private的方法,首先一点它不能被继承,既然不能被继承那么就没办法通过它子类的对象来调用,而只能通过这个类自身的对象来调用。因此就可以说private方法和定义这个方法的类绑定在了一起。
    final方法虽然可以被继承,但不能被重写(覆盖),虽然子类对象可以调用,但是调用的都是父类中所定义的那个final方法,(由此我们可以知道将方法声明为final类型,一是为了防止方法被覆盖,二是为了有效地关闭java中的动态绑定)。
    构造方法也是不能被继承的(网上也有说子类无条件地继承父类的无参数构造函数作为自己的构造函数,不过个人认为这个说法不太恰当,因为我们知道子类是通过super()来调用父类的无参构造方法,来完成对父类的初始化, 而我们使用从父类继承过来的方法是不用这样做的,因此不应该说子类继承了父类的构造方法),因此编译时也可以知道这个构造方法到底是属于哪个类。
    对于static方法,具体的原理我也说不太清。不过根据网上的资料和我自己做的实验可以得出结论:static方法可以被子类继承,但是不能被子类重写(覆盖),但是可以被子类隐藏。(这里意思是说如果父类里有一个static方法,它的子类里如果没有对应的方法,那么当子类对象调用这个方法时就会使用父类中的方法。而如果子类中定义了相同的方法,则会调用子类的中定义的方法。唯一的不同就是,当子类对象上转型为父类对象时,不论子类中有没有定义这个静态方法,该对象都会使用父类中的静态方法。因此这里说静态方法可以被隐藏而不能被覆盖。这与子类隐藏父类中的成员变量是一样的。隐藏和覆盖的区别在于,子类对象转换成父类对象后,能够访问父类被隐藏的变量和方法,而不能访问父类被覆盖的方法)
    由上面我们可以得出结论,如果一个方法不可被继承或者继承后不可被覆盖,那么这个方法就采用的静态绑定。

    与方法不同,在处理java类中的成员变量(实例变量和类变量)时,并不是采用运行时绑定,而是一般意义上的静态绑定。所以在向上转型的情况下,对象的方法可以找到子类,而对象的属性(成员变量)还是父类的属性(子类对父类成员变量的隐藏)。

    java因为什么对属性要采取静态的绑定方法。这是因为静态绑定是有很多的好处,它可以让我们在编译期就发现程序中的错误,而不是在运行期。这样就可以提高程序的运行效率!而对方法采取动态绑定是为了实现多态,多态是java的一大特色。多态也是面向对象的关键技术之一,所以java是以效率为代价来实现多态这是很值得的。

  • 相关阅读:
    MIME 类型(HttpContext.Response.ContentType)列表
    Enterprise Library 5.0 系列文章
    实战HTTP处理程序系列(转)
    Ext.Net 的Panel放入iframe
    使用LINQ Expression构建Query Object
    在.NET Workflow 3.5中使用多线程提高工作流性能
    重温DOS下的小作品:回忆过去,展望将来
    CQRS体系结构模式实践案例:Tiny Library:系统架构
    使用Apworks开发基于CQRS架构的应用程序(二):创建领域模型项目
    经典的应用系统结构、CQRS与事件溯源
  • 原文地址:https://www.cnblogs.com/qwer113/p/9360834.html
Copyright © 2020-2023  润新知