Java基础教程：面向对象编程[3]

内容大纲

基础编程

获取用户输入

　　java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。我们可以查看JavaAPI文档来获取其功能声明：

基本语法：

import java.util.Scanner; 

public class ScannerDemo {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        // 从键盘接收数据

        // next方式接收字符串

        System.out.println("next方式接收：");

        // 判断是否还有输入

        if (scan.hasNext()) {

            String str1 = scan.next();

            System.out.println("输入的数据为：" + str1);

        }

        scan.close();

    }

}

说明：

next():

1、一定要读取到有效字符后才可以结束输入。

2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。

2、可以获得空白。

求多个数的平均和：

class ScannerDemo {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        double sum = 0;

        int m = 0;

        while (scan.hasNextDouble()) {

            double x = scan.nextDouble();

            m = m + 1;

            sum = sum + x;

        }

        System.out.println(m + "个数的和为" + sum);

        System.out.println(m + "个数的平均值是" + (sum / m));

        scan.close();

    }

}

数据输出

说明：

字段摘要：

文档使用说明：

　　首先我们要知道JDK提供了System类用来提供标准输出、标准输入等功能。
　　然后我们要关注功能点，比如我们要标准输出，我们要看他的修饰符及返回类型等信息
1. 　　
　　我们也可以通过其返回类型来对功能或原理进行推测，一般来说，拿来主义即可！比如我们知道了他的返回类型是PrintStream

使用：

        String str="Hello World";

        System.out.println(str);

        System.err.println(str);

文件读写操作

IO流与文件基础

查看教程

Java：IO流与文件基础

文件读

import java.io.*;

public class Main {

    public static void main(String[] args)  {

        try {

            BufferedReader in = new BufferedReader(new FileReader("test.log"));

            String str;

            while ((str = in.readLine()) != null) {

                System.out.println(str);

            }

            System.out.println(str);

        } catch (IOException e) {

        }

    }

}

文件写

import java.io.*;

public class Main {

    public static void main(String[] args)  {

        try {

            BufferedWriter out = new BufferedWriter(new FileWriter("runoob.txt"));

            out.write("菜鸟教程");

            out.close();

            System.out.println("文件创建成功！");

        } catch (IOException e) {

        }

    }

}

Java其他特性

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

static说明：

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 说明：

final 变量：final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法：类中的 final 方法可以被子类继承，但是不能被子类修改。声明 final 方法的主要目的是防止该方法的内容被修改。

final 类：final 类不能被继承，没有类能够继承 final 类的任何特性。

接口与抽象类

Java抽象类：

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
还有抽象类的方法一定是抽象方法，莫忘记加abstract关键字：

接口：

　　接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

　　接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

　　接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与抽象类的区别和联系：

定义方法：

[可见度] interface 接口名称 [extends 其他的类名] {

        // 声明变量

        // 抽象方法

}

实现接口：

public class MammalInt implements Animal{

   public void eat(){

      System.out.println("Mammal eats");

   }

   public void travel(){

      System.out.println("Mammal travels");

   } 

   public int noOfLegs(){

      return 0;

   }

   public static void main(String args[]){

      MammalInt m = new MammalInt();

      m.eat();

      m.travel();

   }

}

异常处理

异常类的层次：

捕获异常：

try

{

   // 程序代码

}catch(ExceptionName e1)

{

   //Catch 块

}

多重捕获异常：

try{

   // 程序代码

}catch(异常类型1 异常的变量名1){

  // 程序代码

}catch(异常类型2 异常的变量名2){

  // 程序代码

}catch(异常类型2 异常的变量名2){

  // 程序代码

}

抛出异常：

import java.io.*;

public class className

{

  public void deposit(double amount) throws RemoteException

  {

    // Method implementation

    throw new RemoteException();

  }

  //Remainder of class definition

}

finally子句：

try{

  // 程序代码

}catch(异常类型1 异常的变量名1){

  // 程序代码

}catch(异常类型2 异常的变量名2){

  // 程序代码

}finally{

  // 程序代码

}

枚举类型

关键字ENUM可以将一组具名的值的有限集合创建为一种新的数据类型，而这些具有名的值可以作为常规的程序组件使用，这是一种非常有用的功能。

除了不能继承ENUM类以外，我们基本上可以将ENUM看做一个常规的类，也就是说我们可以向enum中添加方法，甚至可以有main方法。

定义枚举类型：

package demo;

public enum WeekDay {

    //定义枚举实例

    MONDAY,TWUSDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY("HELLO WORLD");

    //定义属性

    private String description;

    //添加构造器

    private WeekDay()

    {

        System.out.println("Hello");

    }

    private WeekDay(String descrpition)

    {

        this.description =descrpition;

    }

    //添加访问方法

    public String getDescription()

    {

        return this.description;

    }

}

测试方法：

public class EnumMain {

    public static void main(String[] args)

    {

        //获取实例

        WeekDay weekDay = WeekDay.FRIDAY;

        WeekDay weekDay1 = Enum.valueOf(WeekDay.class,"MONDAY");

        //遍历枚举数组

        for(WeekDay day:WeekDay.values())

        {

            System.out.println(day.ordinal()+"|"+day.name());

            if(day==WeekDay.SUNDAY)

            {

                System.out.println(day.getDescription());

            }

        }

    }

}

泛型

查看教程：

Java：泛型基础

重载与重写

重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
好处：重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。
重载规则：

实例：