java的基本语法(一)

下面这些是我自学JAVA的时候摘录的一些笔记，给大家参考一下。

 

【补充理论】接口和继承的区别？
接口中，只有方法，没有定义，这就要求实现接口必须定义实现接口中所有的方法，但继承则不然，此其一；一个类，只能继承自一个基类，但是可以实现多个接口，此其二；
如果对抽象类理解不错的话，你可以吧接口看成一个极度的抽象类，没有实现任何方法；

【继承】
extends 通过继承，子类自动拥有了基类的所有成员(成员变量和方法)

【1.方法的重载】：方法名相同，参数个数不同，类型不同

void max(int a, int b){}
void max(float a,float b){}
void max(byte a,byte b){}

【2.方法的重写】：方法名相同，参数返回类型相同，权限一样

在子类中可以根据需要对从基类（父类）中继承来的方法进行重写
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型
重写方法不能使用比被重写方法更严格的访问权限
class Person{
   public String getInfo(){
    return "Name: "+ name +"\n" +"age: "+ age; 
   }
}

class Student extends Person{
   public String getInfo(){
     return "Name: "+ getName() +"\nage: "+ getAge() +"\nschool: "+ school; 
   }
}

【3.继承中的构造方法】

1)子类的构造过程中【必须】调用其基类的构造方法
2)子类可以再自己的构造方法中使用super(参数列表)调用基类的构造方法
     使用this(参数列表)调用本类的另外的构造方法
     如果调用super,必须写在子类构造方法的第一行
3)如果子类的构造方法中没有显示(没有super)的调用基类构造方法，则系统默认调用基类无
参数的构造方法
4)如果子类构造方法中既没有显示(没有super)调用基类构造方法，而基类中又没有无参的构造
方法，则编译出错。

【5. 抽象类】
用abstract关键字来修饰一个类时，这个类叫做抽象类(含有抽象方法)；abstract class Animal
用abstract关键字来修饰一个方法时，这个类叫做抽象方法(就是让被重写的)；
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
抽象类不能被实例化，抽象方法只需声明，而不需实现。public abstract void enjoy();

【6.static】

    static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
    被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载， Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

    用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

    static 变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

    static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

 【static和final一块用表示什么】
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

【7.Final】 关键字
final 的变量的值赋值后不能被改变：成员变量，局部变量
final 的方法不能被重写,可以被继承
final 的类不能被继承
   
【8.接口 interface】 (所有的方法都是abstract)
 特殊的抽象类，只包含常量和方法的定义，而没有变量和方法的实现
 接口中声明的属性只能/默认是public static final(接口里面可以不写，默认)
 接口里的方法只能是抽象方法。
 多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。
public interface  Runner{
 public static final int id = 1;(属性(成员变量)只能定义为static final)
 public void start();(不需要写实现)
 public void run(); 
 public void stop();
}

class 类名 implements 接口名{}

【9.对象转型】 casting
一个基类的引用类型变量可以"指向"其子类的对象
一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)
可以使用引用变量 Instanceof 类名 来判断该引用型变量所“指向”
的对象是否属于该类或该类的子类
子类的对象可以当做基类的对象来使用称作向上转型(upcasting)向下转型(downcasting)

【10 多态】   !!!!要有继承  要有重写  父类引用指向子类对象!!!
 
动态绑定是指"在执行期间"(而非编译期)判断所引用对象的实际类型,
根据其实际的类型调用其相应的方法

abstract class Animal{
 private String name;
 Animal(String name) {this.name = name;} 
 /*
 public void enjoy(){
  System.out.println("叫声......"); 
 }*/
 
 public abstract void enjoy();
}

class Cat extends Animal{
 private String eyesColor;
 Cat(String n,String c) {super(n); eyesColor = c;}
 public void enjoy(){
  System.out.println("猫叫声......"); 
 } 
}

class Dog extends Animal{
 private String furColor;
 Dog(String n,String c) {super(n); furColor = c;}
 
 public void enjoy(){
  System.out.println("狗叫声......"); 
 } 
}

class Lady{
 private String name;
 private Animal pet;
 Lady(String name,Animal pet){
   this.name = name; this.pet = pet; 
 } 
 public void myPetEnjoy(){pet.enjoy();}
}

public class Test{
 public static void main(String[] args){
   Cat c = new Cat("catname","blue");
   Dog d = new Dog("dogname","black");  
   Lady l1 = new Lady("l1",c);
   Lady l2 = new Lady("l2",d);  
   l1.myPetEnjoy();
   l2.myPetEnjoy(); 
 }
}

 

 

【11.异常的捕获和处理】 try  catch   finally  throw  throws
try代码段后面有一个或多个catch代码段
每个catch代码段声明其能处理的一种特定类型的异常并提供处理的方法
当异常发生时，程序会中止当前的流程，根据获取异常的类型区执行相应的catch代码段。
finally段的代码无论是否发生异常都有执行，当遇到异常时执行完异常在转到finally语句，没有遇到异常时就直接转到finally语句。

 

【finally语句】通常在finally语句中可以进行资源的清除工作：关闭打开的文件,删除临时的文件

try {
 //可能抛出异常的语句
} catch (SomeException1 e)
{
   ... ...
} catch (SomeException2 e)
{
   ... ...
} finally {
   ... ...
}

    下面是具体的例子1
------------------------------------------------------------------------
 void m(int i) throws ArithmeticException{
    if(i == 0)
 throw new ArithmeticException("被除数为0");  //这里throw手动抛出异常
 }
    下面是具体的例子2
------------------------------------------------------------------------
 voif f() throws FileNotFoundException, IOException{    //这里throws自动抛出异常
     FileNotFoundException in = new FileNotFoundException("Myfiel.txt");
     int b;
     b = in.read();
     while(b != -1){
 System.out.print((char) b);
 b = in.read();
     }
}

 voud f2(){
    try{
 f(); //在f2()方法中调用f()方法,因为f()方法中抛出了2个异常,所以调用该方法时要捕获2个异常
    }catch(FileNotFoundException e){
 System.out.print(e.getMessage());
    }catch(IOException e){
 e.printStackTrace();
    }
 }

e.printStackTrace();这个是打印(api里的)异常信息
e.getMessage();    输出自定义的异常信息  (被除数为0)
---------------------------------------------------------------------------------

注意： 重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常。
例如：
class A{
   public void method() thorws IOException {...}
}
calss B1 extends A{   //错了 抛出的异常和A方法不一致
   public void method() throws FileNotFoundExcrption {...}
}
class B2 extends A{   //错了 抛出的异常和A方法不一致
   public void method() throws Exception {...}
}
class B3 extends A{
   public void method() {...}
}
class B4 extends A{   //错了 抛出的异常和A方法不一致
   public void method() throws IOException,MyException{...}
}

 

 

以上这些是之前自学JAVA基础语法的时候自己摘录的，难免有些地方写的不对，请大家多多指教！