面向对象

补充》

static不可被覆盖

abstract

修饰类、方法

设置一个类为abstract，则此类必须被继承使用。

当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。（这里的f1就不能写成  fi（）{     }）

abstract class Father1{
	public abstract void f1();
}

如果一个类中有一个抽象方法，那么这个类一定为一个抽象类。 反之，如果一个类为抽象类，那么其中可能有非抽象的方法。

final

final关键字可以用于成员变量、本地变量、方法以及类。
final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
不能够对final变量再次赋值。
本地变量必须在声明时赋值。
在匿名类中所有变量都必须是final变量。
final方法不能被重写。
final类不能被继承。
final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
final方法在编译阶段绑定，称为静态绑定(static binding)。

没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。

final类型作为传参，则在方法里就不可以再赋值了。

public class FindError{
	//声明
	final int i=10;
	final int j;
	final int k;
	final int l;
	public static final int s=100;
	{
		//i=11;
		j=12;//final只能被赋值一次
	}
	
	FindError()//构造器
	{
		k=13;
		l=1000;//没有在声明的时候初始化的final变量称为空白
		//它们必须在构造器中初始化。不然该构造方法就会报错
		//j=9;final只能被赋值一次
	}
	public void print(final int a){
		final int b; //本地变量必须在声明 的时候赋值
		//a=12;传参的时候就相当于给a赋值了，所以这里再赋值就相当于二次赋值。final类只可以赋一次
		b=13;
		//l=1000;//l声明时未初始化则需要在构造器中初始化
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//s++;//final类型的值不可以改变
		
	}
}
abstract class Father1{
	public abstract void f1();
	//当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效
}
abstract class Son extends Father1{
	
}//继承类也要写成abstract类型
final class Father2{}
//class Son2 extends Father2{}//finnal类不可以被继承
interface in1{}
//class Son3 extends in1{}
class Son3 implements in1{}
//in1是接口 应该用implements
interface in2{}
abstract class Son4 extends Father1{
		//而且继承Father1需要改为abstract类
}
//首先father2类应该是用继承不应该用implements  其次father2类是final类型的不可以被继承
//而且类是单继承的
class Father3{}
class Son5 extends Father3 implements in1,in2{}

class Father4{public  void f(){}}
class Son6 extends Father4{
	public void f(){}
	//父类Father4中f是final类型，子类不能重写该方法  
}

上

class Person
{
	static String shoolname; 
	String name;
	int age;
	private int score=4;
	private static int num=6;
	//******************************
	//定义一个成员方法，用于访问内部类
	public void test()
	{
		Inner inner=new Inner();
		inner.show();
	}
	//定义了一个成员内部类
	class Inner{
		void show()//访问外部类的成员变量
		{
			System.out.println("分数:"+score);
		}
	}
	//**********************************************
	//静态代码块，类加载一次，其执行一次。跟对象个数无关
	static {
		String objct;
		objct="软件工程";
		System.out.println("专业是"+objct);
	}
	//**************************************************
	//静态内部类
	static class Inn{
		void show()
		{
			System.out.println("num="+num);
		}
	}
	//*************************************************
	//方法内部类
	public void tes()
	{
		class In{
			void show() {
				System.out.println("这是方法内部类");
			}
		}
		In in=new In();
		in.show();
	}
	
	
	//**************************************************
	public Person(String con_name,int con_age)
	{
		this.name=con_name;
		age=con_age;
	}
	public Person(String con_name)
	{
		//this必须写到第一行
		this("xiaof",12);//这里xiaof不起作用。主函数里的赋值起作用。但是这里的12起了赋值作用。
		name=con_name;
	}
	public void speak()
	{
		System.out.println("大家好，我叫："+name+",我今年"+age+"岁");
	}
	
}


public class Wwww {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	//	System.out.println("0000");
		
		Person.shoolname="河南大学";//这里所有的对象的schoolname都被赋值了河南大学
		
		//***********************************************************
		//创建内部类的第二种方法
		Person.Inner inner=new Person("w").new Inner();//创建内部类对象，这里的person好像是构造方法
		inner.show();
		//***********************************************************
		
		Person p1=new Person("lf");//创建对象p1
		Person p2=new Person("李芳",18);
		System.out.println("我的学校是"+p1.shoolname);
		p1.speak();
		p2.speak();
		//************************************************************
		Person.Inn inn=new Person.Inn();//注意这里的Person是类名了好像，而且不用new
		inn.show();
		//***************************************************************
		
		p1.tes();//调用 方法内部类的  那个tes方法
		p1.test();//内部类调用test方法第一种
		
		System.gc();//垃圾回收
		
	}

}

下

前三节

class Animal
{
	//******************************************
	public Animal()//父类带参数的构造方法
	{
		System.out.println("这个动物");
	}
	public Animal(String name)//父类带参数的构造方法
	{
		System.out.println("这个动物是"+name);
	}
	//*****************************************
	String name="动物";
	void shout()
	{
		System.out.println("发出叫声");
	}
}
//**********************************************
//=============类的继承    super关键字==============
class Dog extends Animal   //extends 表示继承  注意：java里只支持单类继承
{
	//***********************************
	public Dog()//子类构造方法
	{
		super("金毛");//调用父类有参的构造方法
		//若将此行注释掉，则自动调用父类的无参构造方法，输出的是“这个动物”。
	}
	//注意：在父类里定义了构造方法。子类 里面必须也使用构造方法，不然就会报错。
	//************************************
	String name="犬类";
	public void printfName()
	{
		System.out.println("name="+name);//输出子类name
		System.out.println("name="+super.name);//输出父类name
	}
	//************************************
	void shout()
	{//重写父类方法  
		System.out.println("汪汪");//下面再调用shout函数，输出的是“汪汪”而不是“发出叫声”
		
		super.shout();//访问父类的成员方法
	}
	
}
//***************************************************
//===============final 关键字=========================
//用final修饰的类，将不能被继承，其不能派生子类
final class Person{
	//空
	public final void shout(){
		//用final修饰方法。该方法被修饰后，子类不能重写该方法
		final int num=2;
		final String name1;//错误，使用final修饰成员变量，虚拟机不会对其初始化
		final String names="Lynne";//正确。使用final修饰变量时必须同时对其初始化
		//用final修饰的变量一旦被赋值，其值不能改变。（再次赋值会报错）
	}
}
//*****************************************************
//================抽象类  abstract =========================
abstract class People//定义抽象类
{
	abstract void shout();//定义抽象方法
	//抽象方法的类必须声明为抽象类（也就是people前面也得要abstract）
	//可以在继承中重写shout方法
}
class Stud extends People{
	void shout()
	{
		System.out.println("抽象类继承(重写)方法");
	}
}
//******************************************************
//===============接口  interface======================
//接口中的定义方法默认使用public abstract来修饰,  即抽象方法
//接口中的变量默认使用public static final来修饰 ，即全局常量
interface Car
{
	int ID=1;//定义全局常量
	void speed();
	void price();//定义抽象方法
}
//接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法
//需要一个类，使用 implements关键字实现接口中所有的方法
class Benz implements Car{
	public void speed()
	{
		System.out.println("Benz的速度speed");
	}
	public void price()
	{
		System.out.println("Benz的价格price");
	}
	//接口里的所有抽象方法都得写里面。不然就会报错
}
//接口继承接口
interface USAcar extends Car{  
	void cost_oil();
}
//USAcar接口继承了Car接口，因此USAcar包含三个抽象方法
class Baoma implements USAcar{
	public void speed()
	{
		System.out.println("宝马的速度speed");
	}
	public void price()
	{
		System.out.println("宝马的价格price");
	}
	public void cost_oil()
	{
		System.out.println("宝马耗油cost_oil");
	}
}
//==@@@@@@@@@=====接口归纳总结====@@@@@@@@@@@@========
/*接口中的方法都是抽象的，不能实例化对象（得通过继承实现）
 * 当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，不是抽象类则需要实现所有方法
 * 一个类可以实现多个接口，用逗号隔开
 *同样的，一个接口也可以继承多个接口(如下)
 */
interface Run{
}
interface Fly{
}
interface Eating extends Run,Fly{
}
class Bird implements Run,Fly{
}
//也可以在继承另一个类的同时实现接口
/*class Birds extends Can implements Animal{
	//先继承，再实现
}*/
//****************************************************

public class Wwww {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("=======继承类输出=======");
		Dog dog=new Dog();//实例化子类对象
	//	dog.name="泰迪";
		dog.printfName();
		dog.shout();
		System.out.println("=======抽象类输出=======");
		Stud stud=new Stud();
		stud.shout();
		System.out.println("======================");
		System.out.println("");
		System.out.println("========接口输出========");
		Benz  benz=new Benz();
		benz.price();
		benz.speed();
		System.out.println("------接口继承输出------");
		Baoma bm=new Baoma();
		bm.price();
		bm.speed();
		bm.cost_oil();
		System.out.println("=======================");
		
	}

}

第四节

interface Animal{
	void shout();
}
class Cat implements Animal{
	public void shout()
	{
		System.out.println("猫叫");
	}
	public void sleep()
	{
		System.out.println("猫睡觉");
	}
}
class Dog implements Animal{
	public void shout()
	{
		System.out.println("狗叫");
	}
}

//在同一个方法中。由于参数类型不同而导致执行效果个亿的现象就是多态
//java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
//将子类对象当作父类类型使用
//********************************************************************
//=====================Object类========================
class Car
{
	void name()
	{
		System.out.println("汽车");
	}
}
class Car1
{
	public String toString()
	{
		return "I am a car";
	}
}
public class Wwww {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("=======多态概述=======");
		Animal an1=new Cat();//创建对象，使用Animal类型的变量an1引用
		Animal an2=new Dog();
		animalShout(an1);//调用方法，将an1作为参数传入
		animalShout(an2);
		System.out.println("=====================");
		System.out.println("======对象的类型转换=======");
		Dog dog=new Dog();
		animalShout1(dog);
		System.out.println("=====================");
		
		System.out.println("======object类=======");
		Car car=new Car();
		System.out.println(car.toString());
		//Car默认继承自Object类，输出的是类名+“@”+哈希值 
		System.out.println("------重写toString-------");
		Car1 car1=new Car1();
		System.out.println(car1.toString());
		System.out.println("------匿名内部类-------");
		animalShout(new Cat());
		System.out.println("=====================");
		
		
}
	
	//main函数外：：
	public static void animalShout(Animal an)
	{//定义一个静态的方法，接收Animal 类型的参数
		an.shout();
	}
	//**********************************************
	//对象的类型转换
	public static void animalShout1(Animal animal)
	{//参数是Animal接口
		if(animal instanceof Cat)
		{//这里的关键字instanceof可以判断一个对象是否为某个类或接口的实例或者子类实例
			Cat cat=(Cat)animal;//强制类型转换
			//如果这里不做类型转换，因为调用参数是Animal接口，里面没有sleep（）方法，会报错！
			cat.sleep();
			cat.shout();
		}
		else {//如果不是这个类，就输出不是的
			System.out.println("this animal is not a cat");
		}
	}
	//*************************************************************
	
}

异常

public class Wwww {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//***************************************************
		//对异常的处理方式----异常捕获
		try {		
			int result=divide(4,0);
			System.out.println(result);
			//try代码块中，发生异常语句后面的代码不会被执行
		}catch(Exception e) {
			System.out.println("捕获的异常信息是："+e.getMessage());
		//	return;//加return和finally块，后面的语句都无法执行了
		}
		//finally
		//{
		//	System.out.println("进入finally代码块");
		//}
		System.out.println("程序继续向下执行。。。。");
		//***************************************************
		//==========throw 关键字=========
		try {		
			int result=divide(4,2);
			System.out.println(result);	
		}catch(Exception e) {//对捕获到的异常信息进行处理
			e.printStackTrace();//打印捕获的异常信息
		}
		//注意！！仅用throws抛出异常但是前面并未用catch 进行异常处理，程序还是会终止运行
		//****************************************************
		//
		try {		
			int result=divide(4,2);
			System.out.println(result);	
		}catch(Exception e) {//对捕获到的异常信息进行处理
			e.printStackTrace();//打印捕获的异常信息
		}
	}
	public static int divide(int x,int y) throws Exception//用throws关键字声明抛出异常
	{
		int result=x/y;
		return result;
	}
	public static int divide1(int x,int y) throws DivideByMinusException
	{
		if(y<0)
		{
			throw new DivideByMinusException("被除数是负数");
		}
		int result=x/y;
		return result;
	}
}