Java面向对象编程

如果说C语言程序设计很有意思的话，那该怎么去形容Java才最贴切呢。从现在起，开始深入研究Java面向对象编程。

最基本——创建一个类（class）

一个class类中需要描述出类的属性和方法，比如说现在有一个问题的对象是一只猫，我们需要把它的种类、名字、体重描述出来，同时它可以吃饭、睡觉、玩耍。这时候，我们就需要创建一个Cat类。这里只是简单描述，所以把属性和方法都设置成了public
创建结果如下

class Cat{
	//属性
	String kind;
	String name;
	double weight;
	//构造器
	public Cat(String kind, String name, double weight) {
		super();
		this.kind = kind;
		this.name = name;
		this.weight = weight;
	}
	//方法
	public void play() {
		System.out.println(this.name+"在玩耍");
	}
	public void eat() {
		System.out.println(this.name+"吃了一斤猫粮");
	}
}

OOP三大特征——封装、继承、多态

一、封装

为什么要实现封装？——保护类的一些属性或方法。
使用关键字private进行修饰后的属性或方法之后，就只允许类自身进行修改和使用，其他类则没有权限。这种情况下可以在类内部构造set和get方法供其他类间接访问。

public class test_class {
	public static void main(String[] args) {
		Cat cat=new Cat();
		//cat.weight=3.6;	//会报错！
		System.out.print(cat.getWeight()+"->");
		cat.setWeight(6.2);
		System.out.println(cat.getWeight());
	}
}
class Cat{
	//私有属性
	private double weight=3.2;

	//get方法获取属性
	public double getWeight() {
		return weight;
	}
	//set方法供修改
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
}
//运行结果:3.2->6.2

如果一个属性或方法前面带有关键字fianl修饰的属性和方法，则代表其已是最终的状态，不允许进行任何修改。

有关类和属性的一些修饰符之后的访问权限说明：

1. private 表示私有，只有自己类能访问
2. default表示没有修饰符修饰，只有同一个包的类能访问
3. protected表示可以被同一个包的类以及其他包中的子类访问
4. public表示可以被该项目的所有包中的所有类访问

二、继承

在Java面向对象编程中，类不能实现多继承，但接口（interface）可以，接口先不说。这里使用extend关键字实现继承，但即使是子类也没有直接访问和修改父类属性的权限。这里以上面的Cat类为父类创建一个LettleCat类。

class LettleCat extends Cat{
	
	public void change() {
		this.name="yang1";//非私有可供子类访问
		//this.weigh=6.2;//无权限，会报错
		this.setWeight(6.2); 	//可实现
	}
	
}

在这里，子类可以对父类方法实现重写，super（超）父类可调用父类方法。

public double getWeight() {		//Cat类中getWeight方法的重载
	double a=super.getWeight();	//super调用父类方法
	System.out.println(a);
	return 0;
}

三、多态

人个有志，在Java中类也是如此。子类对父类方法的重写形成了多态的现象。感觉这里没什么好说的，说再多都是花里胡哨，没有一个代码片来的实在。

演示

public class testpolym {
	public static void main(String[] args) {
		aman pro=new programer();
		re_lax(pro);	//传参——程序员类
		aman ac=new Acmer(); 
		re_lax(ac);		//传参——Acmer类
	}
	//用一个方法测试
	static void re_lax(aman per) {
		per.relax();
	}
}
//父类
class aman{
	public void relax() {
		System.out.println("休息一会");
	}
}
//子类——程序员
class programer extends aman{
	public void relax() {
		System.out.println("程序员写了一小段程序");
	}
}
//子类——Acmer
class Acmer extends aman{
	public void relax() {
		System.out.println("Acmer随手ak，无敌是多么寂寞");
	}
}

面向接口编程

前面继承那里提到过，在Java中，类没有多继承，但接口可以多继承，一个类也可以接入多个接口，下面就开始引入接口的探讨。使用interface 声明一个接口，使用implements让一个类连接接口。（这里只是简单说一下接口。。。\很小声）

接口给工程的开发提供了一个模板，接口的引入是的类的创建更加简洁，功能性一目了然。

接口使用时需要注意：接口中写出的只是一个方法的模型，而一个类接入接口时需要将此接口中所有的方法具体实现，同理如果接入多个，则需要一一实现。

程序演示

//接口a
interface a{
	int max=100;
	void face();
}
//接口b
interface b{
	void shout();
}
//接口c实现了多继承
interface c extends a, b{
	//接口的继承与类的继承方式类似，不再写入内容
}
//一个类可接入多个接口
class ren implements a,b{
	
	//必须实现所有接口的所有方法！
	@Override
	public void shout() {
		System.out.println(max);
	}
	@Override
	public void face() {
		System.out.println(max);
	}
}

注释

1. 以上就是前阵学到Java面向对象编程的小总结，写的有些粗糙，只是简述了面向对象编程过程中常用的编程框架，有一部分东西没有进行阐述。

2. 还有就是异常的处理try-catch-finally，什么手动抛出异常，不在这里写下。

在我看来： Java面向对象编程是编程思维方式的一种转变，过去的面向过程的思想中，不管什么牛鬼蛇神全都放在一起，最终实现就行。而面向对象编程这里则是将事物类化，然后就new一个对象直接调用其属性和方法即可。emmm，挺有意思。

层楼终究误少年，自由早晚乱余生！