Java学习（三）

##异常（by catch） throws finally ####1.使用try和catch关键字捕获异常

try{
  //程序代码
}catch(ExceptionName e1)
{
  //catch块
}

####2.throws/throw关键字

如果一个方法没有捕获一个检查性异常，那么该方法必须使用throws来声明。throws放在方法签名的尾部 也可以使用throw抛出异常

package test;
public class classname{
    public void desposit(double amount) throws RemoteException{
        throw new RemoteException();
    }


}

####3.finally关键字

finall用来创建在try代码块后面执行的代码块。 无论是否发生异常finally代码块中的代码总会被执行 在finally代码块中，可以运行清理类型等收尾善后性质的语句 finally代码块出现在catch代码块最后

try{
  //程序代码
}catch{
  //程序代码
}catch{
  //程序代码
}finally{
  //程序代码
}

##多态

1.静态-->重载 2.动态-->重写 ###上转型对象

####1.上转型对象

父类引用指向子类对象。子类和父类中定义同名的变量时，仅仅是隐藏了，变量没有多态性；而对于覆盖的方法，java表现出多态性，会调用更具体的子类里面的方法，无论从哪里调用，无论使用多少引用类型调用。 子类的对象由一个父类的引用关联.

package test;
public class test15{
    public static void main(String[] args){
//        Cup aCup;
//        BrokenCup aBrokenCup=new BrokenCup();
//        aCup=aBrokenCup;
//        aCup.addWater(10);
          Human guest=new Human();
          BrokenCup hisCup=new BrokenCup();
          guest.drink(hisCup, 10);
    }
}


class Cup{
    public void addWater(int w){
        this.water=this.water+w;
    }


    public void drinkWater(int w){
        this.water=this.water-w;
    }


    private int water=0;
}


class BrokenCup extends Cup{
    public void addWater(int w){
        System.out.println("shit ,broken cup");
    }


    public void drinkWater(int w){
        System.out.println("om...num...,no water inside");
    }
}


class Human{
    void drink(Cup aCup,int w){
        aCup.drinkWater(w);
    }
}

####2.重载

在类中可以创建多个方法，他们具有相同的名字，但具有不同的参数和不同的定义。 重载时，方法名要一样，但参数类型和个数不一样，返回值类型可以相同也可以不相同

1.必须具有不同的参数列表； 2.可以有相同的返回类型，只要参数列表不同就可以； 3.可以有不同的访问修饰符； 4.可以抛出不同的异常

####3.重写

1.父类与子类之间的多态性，对父类的函数进行了重新定义。如果在子类中定义某种方法与其父类有相同的名字，就称该方法被重写 2.若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，如需父类中原有的方法，可使用super，该关键字引用了当前类的父类。 3.子类函数的访问修饰权限不能少于父类

1.参数列表必须完全与被重写方法相同，否则不能称其为重写二是重载。 2.返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写二是重载。 3.访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private) 4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常 ####4.重载和重写的区别

重写多态性起作用,对调用被重载过的方法可以大大减少代码输入量，同一方法名只要往里面传递不同的参数就可以拥有不同的功能和返回值。用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般

##SQL语句

sql> CREATE DATABASE DATABASE_NAME;
//创建一个新的数据库


SQL>CREATE DATABASE EXAMPLE;
//创建一个名为EXAMPLE的数据库


SQL>DROP DATABASE EXAMPLE;
//删除EXAMPLE数据库

SQL>CREATE TABLE table_name
(
  column_name column_data_type,
  column_name column_data_type,
  column_name column_data_type
  ...
);
//创建一个新表

SQL>CREATE TABLE students
(
  id INT NOT NULL,
  age INT NOT NULL,
  name VARCHAR(255),
  major VARCHAR(255),
  PRIMARY KEY(id)
  );
//创建一个有四个属性的students表

SQL>DROP TABLE table_name;
//删除现有表

SQL>INSERT INTO table_name VALUES(column1,column2,...);
//插入数据

SQL>SELECT column_name,column_name,...
  FROM table_name
  WHERE conditions;
//查询数据

SQL>UPDATE table_name
  SET column_name=value,column_name=value,...
  WHERE conditions;
//更新数据

SQL>DELETE FROM table_name WHERE conditions;
//删除数据

##作业

写个圆的类 计算周长，面积 。

zhouchang.java

package circle;
public class zhouchang{
    double r;
    public zhouchang(){
        r=10;
    }
    public zhouchang(double r){
        this.r=r;
    }


    public double zhouchangtest(){
        return 2*3.14*r;
    }
}

mianji.java

package circle;
public class mianji{
    double r;
    public mianji(){
        r=4;
}
    public mianji(double r){
        this.r=r;
    }


    public double  mianjitest(){
       return r*r*3.14;
    }
}

circletest.java

package circle;
public class circletest{
    public static void main(String[] args){
        zhouchang c1=new zhouchang();
        zhouchang c2=new zhouchang(30);
        mianji s1=new mianji();
        mianji s2=new mianji(30);
        System.out.println("c1= "+c1.zhouchangtest());
        System.out.println("c2= "+c2.zhouchangtest());
        System.out.println("s1= "+s1.mianjitest());
        System.out.println("s2= "+s2.mianjitest());
    }
}

转载于:https://my.oschina.net/CIIren/blog/540066