黑马程序员---面向对象2

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

1.类的继承
    a.概念：
        类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
        Demo:       

public class Demo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "沙皮狗";
        dog.print();    //调用dog类的print方法
        dog.shout();    //调用 dog类继承来的shout方法
    }
}
class Animal{
    String name;
    void shout(){
        System.out.println("动物发出叫声");
    }
}
class Dog extends Animal{
    public void print(){
        System.out.println("name="+name);
    }
}

        注：在java中只支持单继承，不允许多重继承，也就是说一个类只能由一个直接父类。多个类可以继承一个父类。
            在java中，多层继承是可以。即一个类的父类可以再去继承另外的父类。
            在java中，子类和父类是一种相对的概念，也就是说一个类是某个类的父类的同时，也可以是另一个类的子类。
    b.重写父类方法
        在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。
        Demo：

public class Demo {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();	//调用 dog类重写的shout方法
	}
}
class Animal{
	void shout(){
		System.out.println("动物发出叫声");
	}
}
class Dog extends Animal{
	void shout(){
		System.out.println("旺旺。。。");
	}
}

        注：子类重写父类方法是，不能使用比父类被重写的方法更严格的访问权限。
    c.super关键字
        super关键字用于在子类中访问父类的成员。格式为：super.成员变量    super.成员方法([参数1,参数2...])
        Demo:

public class Demo {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();	//调用 dog对象重写的shout方法
		dog.print();	//调用 dog对象的print方法
	}
}
class Animal{
	String name = "animal";
	public Animal(String name){
		System.out.println("I am a "+name);
	}
	void shout(){
		System.out.println("animal shout!");
	}
}
class Dog extends Animal{
	String name = "dog";
	public Dog(){
		super("沙皮狗");
	}
	void shout(){
		super.shout();
	}
	void print(){
		System.out.println("name="+super.name);
	}
}

        注：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。
            在子类的构造方法中一定会调用父类的某个构造方法。这时可以在子类构造方法中通过super指定调用父类的哪个构造方法，如果没有指定，在实例化对象时，会自动调用父类无参的构造方法。
2.final关键字
    a.特性：
        final修饰的类不能被继承
        final修饰的方法不能被子类重写
        final修饰的变量是常量，只能赋值一次。
    b.final关键字修饰类
        类被final修饰后，该类不可以被继承，也就是不能够派生子类。
    c.final关键字修饰方法
        当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。
    d.final关键字修饰变量
        被final修饰的变量为常量，只能被赋值一次。
        Demo:

public class Example {
	public static void main(String[] args) {
		Student s = new Student();
		s.introduce();
	}
}
class Student{
	final String name;
	public void introduce(){
		System.out.println("I am a student , my name is " + name);
	}
}

        注：程序不能编译通过，因为使用final修饰的成员变量，虚拟机不会对其进行初始化。
3.抽象类和接口
    a.抽象类
        java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。当一个类中包含了抽象方法，该类必须用abstract关键字来修饰。即存在抽象方法的类必为抽象类。但是抽象类中可以不包含任何抽象方法。抽象类不能被实例化，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。
        Demo:

public class Demo {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();	//调用 dog对象的shout方法
	}
}
abstract class Animal{
	abstract void shout();
}
class Dog extends Animal{
	void shout(){
		System.out.println("旺旺...");
	}
}

    b.接口
        如果一个抽象类中的所有方法都是抽象的，则这个类可以定义为接口。即接口是特殊的抽象类。
        接口中的方法都使用默认的"public abstract"来修饰，即抽象方法。
        接口中的变量都使用默认的"public static final"来修饰，即全局常量。
        接口还可以使用extends关键字去继承另一个接口。
        Demo:

public class Demo {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.breathe();	
		dog.run();
		dog.liveOnLand();
	}
}
interface Animal{
	int ID = 1;//必须初始化，因为final修饰的成员变量，虚拟机不给初始化
	void breathe();
	void run();
}
interface LandAnimal extends Animal{
	void liveOnLand();
}
class Dog implements LandAnimal{
	public void breathe() {
		System.out.println("狗在呼吸");
	}
	public void run() {
		System.out.println("狗在跑");
	}
	public void liveOnLand() {
		System.out.println("狗生活在陆地上");
	}
}       

        注：接口中的方法都是抽象的，不能实例化对象
            当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则，需要实现接口中的所有方法。
            一个类通过implements关键字实现接口时，可以实现多个接口，被实现的多个接口之间用逗号隔开。
            一个接口可以通过extends关键字继承多个接口，接口之间用逗号隔开。
            一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。
4.多态
    a.概述
        指根据引用对象类型的不同，当不同的引用对象调用同一个方法时，会产生不同的行为。即使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
        Demo:

public class Demo {
	public static void main(String[] args) {
		Animal a1 = new Cat();
		Animal a2 = new Dog();
		a1.shout();
		a2.shout();
	}
}
interface Animal{
	void shout();
}
class Dog implements Animal{
	public void shout() {
		System.out.println("汪汪...");
	}
}
class Cat implements Animal{
	public void shout() {
		System.out.println("喵喵...");
	}
}

        注：多态形成的三个条件：有继承    有方法的重写    有父类引用指向子类对象
    b.对象的类型转换
        在多态中，不能通过父类变量去调用子类中的某些方法。
        Demo:

public class Demo {
	public static void main(String[] args) {
		Animal a1 = new Cat();
		a1.shout();
		a1.sleep();
	}
}
interface Animal{
	void shout();
}
class Cat implements Animal{
	public void shout() {
		System.out.println("喵喵...");
	}
	public void sleep(){
		System.out.println("猫睡觉...");
	}
}

        注：此时编译出错，因为a1是一个父类的引用，它无法看到子类中新增的方法sleep()。
    c.Object类
        Object类是所有类的父类，即每个类都直接或间接继承自该类。
    d.匿名内部类
        如果方法的参数被定义为一个接口类型，那么就需要定义一个类来实现接口，并根据该类进行对象实例化。除此之外，还可以使用匿名内部类来实现接口。
        Demo：

public class Demo {
	public static void main(String[] args) {
		class Cat implements Animal{
			public void shout() {
				System.out.println("喵喵...");
			}
		}
		new Cat().shout();
	}
}
interface Animal{
	void shout();
}

5.异常
    a.java中提供了大量的异常类，这些类都继承自java.lang.Throwable类。                            
        Error类称为错误类，它表示java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。
        Exception类称为异常类，它表示程序本身可以处理的错误，在开发java程序中进行的异常处理，都是针对Exception类及其子类。在Exception类的众多子类中有一个特殊的RuntimeException类，该类及其子类用于表示运行时异常，除了此类，Exception类下所有其他的子类都用于表示编译时异常。
        Thorwable类常用方法：
            String getMessage()        返回此thorwable的详细消息字符串
            void printStackTrace()        将此throwable及其追踪输出至标准错误流
            void printStackTrace(PrintStream s)            将此throwable及其追踪输出到指定的输出流
    b.try...catch和finally
        异常捕获使用try...catch语句，语法格式为：
            try{
                //程序代码块
            }catch(ExceptionType(Exception类及其子类) e){
                //对ExceptionType的出路
            }
        Demo:

public class ExceptionDemo {
	public static void main(String[] args) {
		try {
			int result = divide(4,0);
			System.out.println(result);
		} catch (Exception e) {
			System.out.println("捕获的异常信息为：" + e.getMessage());
		}
		System.out.println("程序继续向下执行...");
	}
	public static int divide(int x, int y){
		return x/y;
	}
}

        注：在try代码块中编写可能发生异常的java语句，catch代码块中编写针对异常进行处理的代码。当try代码块的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能接收的异常类型，这个参数的类型必须是Exception类或其子类。
        扩展：try代码块中，发生异常语句后面的代码是不会被执行的，有时我们希望有些语句无论程序是否发生异常都要执行，这时我们就可以在try...catch语句后，加一个finally代码块。
        Demo:

public class ExceptionDemo {
	public static void main(String[] args) {
		try {
			int result = divide(4,0);
			System.out.println(result);
		} catch (Exception e) {
			System.out.println("捕获的异常信息为：" + e.getMessage());
			return;
		} finally{
			System.out.println("进入finally代码块....");
		}
		System.out.println("程序继续向下执行...");
	}
	public static int divide(int x, int y){
		return x/y;
	}
}

        注：不论程序是发生异常还是使用return语句结束，finally中的语句都会执行。
    c.throws关键字
        java允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用该方法时，就明确的知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。语法：修饰符 返回值类型 方法名([参数1,参数2...]) throws ExceptionType1[,ExceptionType2...]    {}
        Demo:

public class ExceptionDemo {
	public static void main(String[] args) {
		try {
			int result = divide(4,0);
			System.out.println(result);
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
	public static int divide(int x, int y) throws Exception{
		return x/y;
	}
}

        注：divide方法声明抛出了异常，调用者在调用该方法时就必须处理该异常，当然也可将该异常继续向上抛。
    d.运行时异常和编译时异常
        1)编译时异常
            程序在编译时产生一些的异常，这些异常必须要进行处理。
            处理方法：
                使用try...catch语句对异常进行捕获
                使用throws关键字声明抛出异常，调用者对其处理
        2)运行时异常
            在程序运行时产生的异常，即使不编写异常处理代码，也可以通过编译。
            RuntimeException类及其子类都是运行时异常。
    e.自定义异常
        java中允许用户自定义异常，但自定义异常类必须继承自Exception或其子类。
        Demo:    

public class ExceptionDemo {
	public static void main(String[] args) {
		try {
			int result = divide(4,-2);
			System.out.println(result);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		} 
	}
	public static int divide(int x, int y) throws Exception{
		if(y<0){
			throw new DivideByMinusException("被除数是负数");
		}
		return x/y;
	}
}
class DivideByMinusException extends Exception{
	public DivideByMinusException(){
		super();
	}
	public DivideByMinusException(String message){
		super(message);
	}
}

        注：当被调用的方法抛出异常时，调用者本身要对该异常进行处理。
6.包
    a.目的：对编写的类进行分目录存放。
        包的声明只能为了java源文件的第一行
    b.import语句
        java中提供import关键字，使用import可以在程序中导入某个指定包下的类，这样就不必在每次用到该类时都书写完整类名了。
        格式： import 包名.类名；
        java语言常用的包：
            java.lang:包含java语言的核心类，如String,Math,System和Thread类等，使用这个包中的类不需要import语句导入，系统自动加载。
            java.util:包含java中大量工具类、集合类等，如Arrays,List,Set等。
            java.net:包含java网络编程相关的类和接口。
            java.io:包含了java输入、输出有关的类和接口。
            java.awt:包含用于构建图形界面(GUI)的相关类和接口。
7.访问控制
    java中，针对类、成员方法和属性提供了四种访问级别，分别是private,default,protected,public。控制级别由小到大依次列出
        private->default->protected->public
        private：只能被该类的其他成员访问，其他类无法直接访问。
        default: 这个类或者类的成员只能被本包中的其他类访问
        protected:该类的成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
        public:该类的成员能被所有的类访问。

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------