java-面向对象（下）

1.继承

（1）extends关键字使用：

class Animal{
	String name;
	void shout(){
		System.out.println("shout");
	}
}
class Dog extends Animal{
	public void printname(){
		System.out.println(name);
	}
}
public class Example{
	public static main(String[] args){
		Dog x=new Dog();
		x.shout()；//输出为shout
		x.name="柴柴"；
		x.printname()；
	}
}

注：一个类只能有一个直接父类；多个类可以继承同一个父类；允许多层继承

（2）重写父类方法：

class Animal{
	String name;
	void shout(){
		System.out.println("shout");
	}
}
class Dog extends Animal{
	public void shout(){
		System.out.println("汪。。");
	}
}
public class Example{
	public static main(String[] args){
		Dog x=new Dog();
		x.shout()；//输出为汪。。
		x.name="柴柴"；
	}
}

（3）super关键字
解决的问题：当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法。
super关键字调用父类的成员变量和成员方法：

class Animal{
	String name;
	void shout(){
		System.out.println("shout");
	}
}
class Dog extends Animal{
	public void shout(){
		super.shout();
	}
}
public class Example{
	public static void main(String[] args){
		Dog x=new Dog();
		x.shout()；//输出为=shout
		x.name="柴柴"；
	}
}

使用super关键字调用父类的构造方法：
（必须放在子类构造方法的第一行，并且只能出现一次）

class Animal{
	public Animal(String name){
		System.out.println(name);
	}
}
class Dog extends Animal{
	public Dog(){
		super("dog");//调用父类有参的构造函数
	}
}

注：在子类的构造方法中一定会调用父类的某个构造方法，如果没用super指定，则默认使用无参的构造方法。
（4）Object类
它是所有类的父类，当类没有指定extends哪个父类时，则默认继承自Object类。

方法声明	功能描述
boolean equals(Object obj)	判断某个对象与此对象是否相等
final Class<?>getClass()	返回此Object的运行时类
int hashCode()	返回贵对象的哈希码值
String toString()	返回该对象的字符串表示
void finalize()	垃圾回收器调动此方法来清理没有被任何引用变量所引用对象的资源

2.final关键字

• final修饰的类为最终类，不能被继承
• final修饰的方法不能被子类重写
• final关键之修饰的变量为常量，只能被赋值一次

3.抽象类

使用abstract关键字来进行修饰的类。
包含抽象方法的类必须是抽象类；抽象类内不一定含有抽象方法。
抽象类不能被实例化，抽象方法不可以被调用；想要调用抽象类中的抽象方法，需要创建一个子类，在子类中实现抽象类的抽象方法。

//定义抽象类
abstract class Animal{
	public void shout();//定义抽象方法
}
class Dog extends Animal{
	public void shout(){
		System.out.println("汪。。");
	}
}
public class Example{
	public static void main(String[] args){
		Dog x=new Dog();
		x.shout();
	}
}

4.接口

• 接口指一个抽象类中所有方法都是抽象的。不适用class关键字，使用interface关键字。
• JDK8中对接口的重新定义为：接口中除了有抽象方法，还可以有默认方法和静态方法（类方法）；默认方法适用default修饰，静态方法适用static修饰；且这两种方法均可以有方法体。
• 定义一个接口时，可以同时继承多个父接口。
• 接口中定义常量时，必须进行初始化赋值。

定义接口的实现类要用implements关键字。但接口的实现类必须实现接口中的所有抽象方法。

interface Animal{
	int age;
	void shout();//定义抽象类
	//定义默认方法
	default void getName(String name){
		System.out.println(name);
	}
	//定义静态方法
	static void getName(){
		return Animal.age;
	}
}
class Dog implements Animal{
	//实现shout方法
	public void shout(){
		System.out.println("wang..");
	}
}

接口与接口之间也可以有继承关系，使用extends关键字。

interface Animal{
	int age;
	void shout();//定义抽象类
	//定义默认方法
	default void getName(String name){
		System.out.println(name);
	}
	//定义静态方法
	static void getName(){
		return Animal.age;
	}
}
interface Dog extends Animal{
	void run();//定义一个抽象方法
	//该接口一共有两个抽象方法
}

注：一个类在继承一个类的同时还可以实现 接口，此时extends关键字必须在implements关键字之前。

5.多态

多态指不同类的对象在调用同一个方法时所呈现出的多种不同行为。
java的多态是由类的继承、方法重写以及父类引用指向子类对象体现的。
（1）对象的类型转换
在多态的学习中，涉及将子类对象当做父类使用的情况，此时不能通过父类变量调用子类特有的方法。

Animal an1=new Cat();//向上转型
Cat cat=(Cat) an1;//对象类型转换，向下转型

java关键字“instanceof”，用来判断一个对象是否为某个类（或接口）的实例或者子类实例。

Animal an1=new Cat();
if(an1 instanceof Cat):
	Cat cat =(Cat) an1;

6.内部类

在一个类的内部定义类，内部的类成为内部类，这个内部类所在的类称为外部类。
（1）成员内部类
在一个类中除了可以定义成员变量，成员方法，还可以定义成员内部类。

class Outer{
	int m;//定义成员变量
	void test1(){
		System.out.println("这是外部类");
	}//定义成员方法
	class inner{
		int n;//定义内部类成员变量
		void show1(){
			//内部类的成员方法可以调用外部类的变量和方法
			System.out.println(m);
			test1();
		}
	}
	void test2(){
		//外部类的成员方法也可以调用内部类的变量和方法
		System.out.println("inner.n");
		inner.show1();
		
	}
}

Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();//通过外部类对象创建内部类对象

（2）局部内部类（方法内部类）
定义在某个局部范围中的类，是在方法中定义的，其有效范围只局限于方法内部。

class Outer{
	int m;//定义成员变量
	void test1(){
		System.out.println("这是外部类");
	}//定义成员方法
	void test2(){
		//外部类的成员方法也可以调用内部类的变量和方法
		class inner{
			int n;//定义内部类成员变量
			void show1(){
				//内部类的成员方法可以调用外部类的变量和方法
				System.out.println(m);
				test1();
			}
		}
		Inner inner=new Inner();
		System.out.println("inner.n");
		inner.show1();
		
	}
}

（3）静态内部类
静态内部类，在成员内部类前加了关键字static
与成员内部类的区别：静态内部类中只能访问外部类的静态成员；通过外部类访问静态内部类成员时，可以跳过外部类直接通过内部类访问静态内部成员。
（4）匿名内部类
指的是没有名称的内部类。
在调用包含接口类型参数的方法时，通常为了简化代码，不会创建一个接口的实现类作为方法参数传入，而是直接通过匿名类的形式传入一个接口类型参数，在匿名内部类中直接完成。
其基本语法格式为：

new 父接口(){
	//匿名内部类实现部分
}
//例子
interface Animal{
	void shout();
}
public class Example{
	public static void main(String[] args){
		//定义匿名内部类作为参数传递给animalShout()
		animalShout(new Animal(){
			public void shout(){
				System.out.println("miao");
			}
		});
	}
	//定义静态方法animalShout()，接收接口类型数据
	public static void animalShout(Animal an){
		an.shout();
	}
}

（7）JDK8的lambda表达式
lambda表达式作用是使用简洁的表达式来表达一个接口。只针对有一个抽象方法的接口实现。

([数据类型 参数名；数据类型 参数名])->{表达式主体}
//例子
interface Animal{
	void shout();
}
public class Example{
	public static void main(String[] args){
		//定义匿名内部类作为参数传递给animalShout()
		animalShout(
			()->{System.out.println("miao");}//lambda表达式
		);
	}
	//定义静态方法animalShout()，接收接口类型数据
	public static void animalShout(Animal an){
		an.shout();
	}
}

在JDK8中，转为为函数接口引入了一个@FunctionalInterface注解，该注解只是显示的标注接口是一个函数式接口，并强制编辑器进行更加严格的检查，确保该接口时函数式接口。

@FunctionalInterface
interface Animal{
	void shout();
}
public class Example{
	public static void main(String[] args){
		//定义匿名内部类作为参数传递给animalShout()
		animalShout(
			()->{System.out.println("miao");}//lambda表达式
		);
	}
	//定义静态方法animalShout()，接收接口类型数据
	public static void animalShout(Animal an){
		an.shout();
	}
}

8.异常

java中的异常类都继承自java.lang.Throwable类
Throwable类的常用方法：

方法声明	功能描述
String getMessage()	返回详细消息字符串
void printStackTrace()	追踪输出至标准错误流
void printStackTrace(PrintStream s)	追踪输出至指定的输出流

（1）异常的类型
编译时异常
运行时异常：一般由程序中的逻辑错误引起
（2）try…catch（异常捕获）和finally

try{
	//可能发生的异常语句
}
catch(Exception类或其子类）{
	//对捕获的异常进行处理
}

在try代码块中发生异常语句后面的代码是不会被执行的，为了让其执行，可以加一个finally代码块。注意如果在try代码块中执行了System.exit(0)语句，因为退出了java虚拟机，因此任何代码都不能被执行。

try{
	//可能发生的异常语句
}
catch(Exception类或其子类）{
	//对捕获的异常进行处理
}
finally{
	//想让程序执行的语句
}

（3）throws关键字
有些时候，方法中代码是否出现异常，开发者并不明确或者不急于处理，为此，需要将这种异常从当前方法中抛出。
throws关键字用在方法声明中，用来指明方法可能抛出的多个异常。

public static int divide(int x,int y) throws Exception{
	int result=x/y;
	return result;
}

（4）throw关键字
throw用于方法体中，并且抛出的是一个异常类对象。
通过throw关键字抛出异常后，还需要使用throws或者try catch对异常进行处理。

public static void printAge(int age) throws Exception{
	if(age<=0){
		throw new Exception("error");
	}
}

（5）自定义异常
自定义的异常必须继承自Exception或其子类。在构造方法中使用super()语句调用Exception中的构造方法即可。
使用时在程序制定位置通过throw关键字抛出异常并进行异常处理。

//自定义异常
public class Divid extends Exception{
	public Divid(){
		super();
	}
	public Divid(String message){
		super;
	}
}
public class Example{
	public static int divid(int x,int y) throws Divid{
		if(y==0){
			throw new Divid("除数是0");
		}
		int result=x/y;
		return result;
	}
	public static void main(string[] args){
		try{
			int result=divide(4,0);
			System.out.println(result);
		}
		catch(Divid e){
			System.out.println(e.getMassage());
		}
	}
}

9.垃圾回收
在java中当一个对象成为垃圾后，仍会占用内存空间，会导致内存空间的不足，因此java引入了垃圾回收机制。java虚拟机会自动回收垃圾对象所占用的内存空间。
强制系统进行垃圾回收的方法
（1）调用System类的gc（）静态方法：
（2）调用Runtime对象的gc（）实例方法：

System.gc();
Runtime.getRuntime().gc();

9.例子

package com.csh.helloworld;
class Student4{
    int age;
    String name;
    public Student4(){

    }//要有，要不子类构造方法报错
    public Student4(int age,String nama){
        this.age=age;
        this.name=name;
    }
    void show(){
        System.out.println("age:"+age);
        System.out.println("name:"+name);
    }
}
class Undergraduate extends Student4{
    String degree;
    public Undergraduate(int age,String name,String degree){
        this.age=age;
        this.name=name;
        this.degree=degree;
    }
    void show(){
        System.out.println("age:"+age);
        System.out.println("name:"+name);
        System.out.println("degree:"+degree);
    }
}
public class Chapter4_1 {
    public static void main(String[] args) {
        Student4 stu=new Student4(18,"wang");
        Undergraduate ug=new Undergraduate(18,"wang","本科");
        stu.show();
        ug.show();
    }
}

package com.csh.helloworld;
interface Shape{
    double area(double a);
}
class Square implements Shape{
    public double area(double a){
        System.out.println("边长为"+a+"的正方形的面积为："+a*a);
        return a*a;
    }
}
class Circle implements Shape{
    public double area(double a){
        System.out.println("半径为"+a+"的圆形的面积为："+3.14*a*a);
        return 3.14*a*a;
    }
}
public class Chapter4_2 {
    public static void main(String[] args) {
        Square s=new Square();
        s.area(2);
        Circle c=new Circle();
        c.area(3);
    }
}