java学习笔记（3）

最新推荐文章于 2021-12-20 14:06:01 发布

yjli98

最新推荐文章于 2021-12-20 14:06:01 发布

阅读量122

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/weixin_42345025/article/details/87281683

版权

学习笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

接口：

接口里的方法是没有方法体的，接口里定义的方法需要在其子类中实现

抽象类中有抽象的方法和普通的方法；接口里的方法全为抽象的，接口中的方法不可以时final或static的，也不能使用public以外修饰符（都是public）

抽象类中可以有成员变量，而接口中的变量都是默认public static final类型即常量

package com.test;

public interface itface {
    public int getMax();
    String getMes();
}

package com.test;

import com.test.itface;

public class itf implements itface
{
    public int getMax()
    {
        int i=123;
        return i;
    }
    public String getMes()
    {
        String s="realize interface method";
        return s;
    }
    public static void main(String[] args)
    {
        itf it=new itf();
        int i=it.getMax();
        String s=it.getMes();
        System.out.println(i);
        System.out.println(s);
    }

}

一道相关java面试问题-----来自http://www.importnew.com/22083.html

抽象类（abstract class）和接口（interface）有什么异同？
答：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

instanceof 检查实例、测试对象是否创建成功（不能比较基本数据类型、右边比较的类型只能为类和接口、比较是基于多态的）

interface fruit---------class ora implements fruit----------class apple : ora o=new ora-------apple a=new a：

o instanceof ora--->true ; o instanceof fruit--->true ; a instanceof fruit--->false

Java中创建对象的五种方式--copy自https://blog.csdn.net/PORSCHE_GT3RS/article/details/81516634

1)使用new关键字创建对象

2)使用Class类的newInstance方法（反射机制）：这个newInstance方法调用无参的构造器创建对象

3)使用Constructor类的newInstance方法（反射机制）：通过这个newInstance方法调用有参数的和私有的构造函数

4)使用Clone创建对象：要想使用clone方法，我们就必须先实现Cloneable接口并实现其定义的clone方法

5)使用（反）序列化机制创建对象：需要让我们的类实现Serializable接口

构造器：必须没有返回类型、可以有多种形式、

public类型的构造器：能让所有类访问到

private修饰构造器：只能本类访问，可声明一个public类型方法来返回对象引用:

...

private apple()
{
    System.out.println("construct");
}
public static apple getTest()
{
    return new apple();
}
...

因为继承：会默认调用方法super进入父类father进行初始化，完毕后回到子类构造器继续执行。

package com.test;
class father
{
    public father()
    {
        System.out.println("father construct");
    }
}
public class bike extends father{
    public bike()
    {
        System.out.println("son construct");
    }
    public static void main(String[] args)
    {
        bike b=new bike();

    }
}

运行结果：father construct
son construct

子类构造器中：super("xxx");可调用父类中参数类型为String类型的构造器

单子模式：某一个类再同一时刻只允许有一个对象：private构造器，public返回对象的引用

package com.test;

class bikee{
    private static bikee bik;//定义一个私有静态成员变量bik
    private bikee()
    {
        System.out.println("construct");
    }
    public static bikee getBike()
    {
        if(bik==null)
            bik=new bikee();
        return bik;
    }
    public void getMes()
    {
        System.out.println("单子模式");
    }
}
public class bike
{
    public static void main(String[] args)
    {
        bikee b=bikee.getBike();
        b.getMes();
        bikee c=bikee.getBike();
        c.getMes();
        bikee cc=bikee.getBike();
        cc.getMes();
        if(b==c&&c==cc)
            System.out.println("指向同一个对象");
    }
}

运行结果：

构造器的运行：

package com.test;

class fath
{
    static
    {
        System.out.println("father's static block");
    }
    public String color;
    public fath()
    {
        System.out.println("father's constructor with no args");
    }
    public fath(String color)
    {
        this.color=color;
        System.out.println("father's constructor with one arg");
    }
    public void show()
    {
        System.out.println("method operated");
    }
}
class sonn extends fath
{
    static
    {
        System.out.println("son's static block");
    }
    public int size;
    public sonn(int Size)
    {
        super("yellow");
        this.size=Size;
        System.out.println("son's constuctor");
    }

    @Override
    public void show() {
        System.out.println(this.color+":"+this.size);
    }
}
public class constru {
    public static void main(String[] args)
    {
        sonn s=new sonn(23);
        s.show();
    }

}

result:先初始化父类的静态块静态成员变量；再初始化子类的静态块静态成员变量；进入父类构造器执行构造器的方法体；执行子类的构造器方法体；最后执行相应的方法。

构造器的执行顺序？

每个类在构建对象时，都会调用父类构造器，先构建父类对象；

每个类在构建对象时，都会先调用父类构造器，构建父类对象，如果父类还有父类，那么会先调用爷爷类的构造器，，，一直到object。

查看代码块的执行顺序:
class Demo{
   {
       System.out.println("block-2");
   }

   Demo(){
       System.out.println("Constructor");
   }

   {
       System.out.println("block-1");
   }

   static{
       System.out.println("static block-1");
   }

   static{
       System.out.println("static block-2");
   }
}

public class BlockDemo{
   public static void main(String[] args){
       Demo d1 = new Demo();
       Demo d2 = new Demo();
   }
}

代码块执行顺序:
static block-1
static block-2
block-2
block-1
Constructor
block-2
block-1
Constructor

继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

1、子类拥有父类非private的属性和方法。

2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。

构造器而言，它只能够被调用，而不能被继承。调用父类的构造方法我们使用super()即可。

---------------------
作者：czz1141979570
来源：CSDN
原文：https://blog.csdn.net/czz1141979570/article/details/80027581

package com.test;

public class abc {
    public static void main(String[] args)
    {
        A ab=new B();
        System.out.println("-------------");
        ab=new B();
        System.out.println("-------------");
        A as=new B();
    }

}
class A
{
    static
    {
        System.out.println("1");
    }
    public A()
    {
        System.out.println("2");
    }
}
class B extends A
{
    static
    {
        System.out.println("a");
    }
    public B()
    {
        System.out.println("b");
    }
}

运行结果：

1 ---------------（1和a为static block、第一次时初始化）
a
2
b
-------------
2
b
-------------
2
b

Process finished with exit code 0