Java 问题总结 - Corn1ng's Blog

restful

想在表单中实现put 和 delete 方法，就埋一个hidden，name为 _method，值为delete。然后在控制器中使用RequestMethod.PUT 就可以了。

再在web.xml中配置filter:org.springframework.web.filter.HiddenHttpMethodFilter 就可以了。

Springmvc 上传图片达到指定位置，并能够用Tomcat 访问

勾上 IDEA 的 deploy applications configured in tomcat instance.

Static 关键字

如果现在有些属性希望被所有对象共享，则必须将其声明为static 属性，如果一个类中的方法想由类调用，则可以声明为static 方法。

1 使用static 声明属性，成为全局属性，所有对象共用。类名直接调用。

2 使用static 声明方法可以用类名直接调用。

继承

在继承的操作中，对于子类对象的实例化，首先调用父类的构造方法，再调用子类的构造方法，

重写与重载

方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

Super关键字

使用super 关键字可以从子类中调用父类中的构造方法，普通方法和属性。

final 关键字

final在Java中表示的意思是最终，可以用final 关键字声明类，属性，方法。

final声明的类不能有子类
final 声明方法不能被子类所覆写
final 声明的变量即成为常量，不能被修改。

使用final 声明时，要求全部的字母大写。

抽象类

Java中创建一种类专门当作父类，这种类被称为抽象类。不能由抽象类直接创建对象，只能通过抽象类派生出新的类，再由新的类创建对象。抽象类中同样有单继承的缺陷。

包含一个抽象方法的类必须是抽象类。
抽象类和抽象方法都要用abstract 声明。
抽象方法只需声明不需要实现
抽象类必须被子继承，子类如果不是抽象类就必须覆写抽象类中全部抽象方法。

接口

接口中可以有变量和方法，但是要注意，接口中变量会被隐式的指定为 public static final 变量。方法会被隐式的指定为public abstract 方法。一般情况下不在接口中定义变量。

对象的多态性

对象的多态性有两种类型

向上转型子类——> 父类向下转型父类——> 子类

向上转型，程序自动完成，向下转型，需要明确指出子类类型。

instanceof 关键字

判断到底是哪个类的实例

1	对象 instanceof 类 ----> 返回Boolean值

抽象类接口的具体应用

抽象类-模板

人可以说话，人有姓名，学生和老师各自说的话不一样，这时人就可以设为抽象类，当做模板。

接口-制定标准

对行为的抽象。比如一个电脑要USB的设备才可以插入，那么鼠标，键盘都实现了USB 接口，就可以插入。

interface USB
{
    void start();
    void stop();
}
class computer
{
    public static void plugin(USB usb)  // 只要USB 就可以插入
    {
        usb.start();
        usb.stop();
    }
}
class Flash implements USB
{
    public void start()
    {
        System.out.println("  flash start");
    }
     public void stop()
    {
        System.out.println("  flash stop");
    }
}
class Disk implements USB
{
    public void start()
    {
        System.out.println("  disk start");
    }
     public void stop()
    {
        System.out.println("  disk stop");
    }
}
public class test()
{
    public static void main(String args[])
    {
        computer.plugin(new Falsh()); //插入 flash 
        computer.plugin(new Disk); // 插入 disk
    }
}

异常 (try catch finally)

在Java 异常结构中，有两个最常用的类，分别是Exception 和 Error 。这两个类都是Throwable的子类，

throws 和 throw

在定义一个方法时可以用throws 关键字进行声明。使用throws 声明的方法表示此方法不处理异常，而交给方法的调用进行处理。

class Math
{
    public int div(int i,int j) throws Exception//方法不处理异常 
    {
        int temp=i/j;
      	return temp;
    }
}

因为除法操作可能产生异常，也可能不产生，所以使用了 throws 关键字，表示不论是否有异常，在调用方法处都必须进行异常处理。

//处理异常
public class demo
{
    public static void main(String[] args)
    {
        Math m =new Math();
      // 因为throws 所以必须处理异常
      try
      {m.div(10,2);}
      catch(Exception e)
      {e.printStackTrace();}
    }
}

主方法中抛出异常，那么就交给JVM 处理，自己不用处理异常了。

与throws 不同的是，可以直接使用throw抛出一个异常，抛出时直接抛出异常类的实例化对象即可。

public class demo
{
    public static void main(String[] args)
    {
        try
        {
            throw new Exception("自己抛出的异常");
        }
      catch(Exception e)
      {
          System.out.println(e);
      }
    }
}

Exception 类与 RuntimeException

Exception 在程序中必须使用try catch 进行处理

RuntimeException 可以不用try catch 进行处理，有异常发生的话，交给JVM.

Contents