Java复习概要——面向对象编程的四大特征

一、抽象

1、定义：我们在定义一个类的时候，实际上就是把一类事物的共有的属性和行为提取出来，形成一个物理模型，这种研究问题的方法称为抽象。

二、封装

1、定义：封装就是把抽象出来的数据和对象的操作封装在一起，数据被保护在内部，程序的其他部分只有通过授权（成员方法），才能对数据进行操作。

2、访问控制修饰符

     java提供四种访问控制修饰符号控制方法和对变量的访问权限：

（1）公开级：用public进行修饰，对外公开

（2）受保护级别：用protected进行修饰，对子类和同一个包中的类公开

（3）默认级：没有修饰符号，向同一个包的类公开

（4）私有级别：用private修饰，只有类本身可以访问，不对外公开

4种访问级别的访问范围
访问级别	访问控制修饰符	同类	同包	子类	不同包
公  开	Public	√	√	√	√
受保护	Protected	√	√	√	╳
默  认	没有修饰符	√	√	╳	╳
私  有	private	√	╳	╳	╳

三、继承

1、继承可以解决代码复用，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends继承。

2、子类通过super来继承父类的构造函数和成员方法。

四、多态

1、所谓多态，就是指引用在不同情况下的多种状态，实现多条的两种方式时继承和接口

2、演示

package face_to_object;
/**
 * 多重多态
 * @author 凡心所向，素履以往，生如逆旅，一苇一航
 *
 */
public class javabase_duotai {
	public static void main(String[] agrs) {
		//非多态演示
		System.out.println("非多态演示：");
		Mao cat = new Mao();
		cat.cry();
		Gou gou = new Gou();
		gou.cry();
		System.out.println();
		//多态演示
		System.out.println("多态演示");
		Dongwu an = new Mao();
		an.cry();
		System.out.println();
		//多重多态演示
		Master master = new Master();
		master.feed(new Gou(), new Bone());
		master.feed(new Mao(),new Fish() );
		
	}
}

//动物类
class Dongwu{
	String name;
	int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void cry() {  //方法覆盖
		System.out.println("我不知道怎么叫");
	}
	
	public void eat() {   //方法覆盖
		System.out.println("我不知道吃什么");
	}
}

//食物类
class Food{
	String name;
	
	public void showName() {
		System.out.println("我是食物");
	}
}

//主人类
class Master{
	
	public void feed(Dongwu an,Food f) {
		an.eat();
		f.showName();
	}
}

//猫类
class Mao extends Dongwu{
	
	public void cry() {
		System.out.println("喵喵叫");
	}
	
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
}

//狗类
class Gou extends Dongwu{
	
	public void cry() {
		System.out.println("汪汪叫");
	}
	
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

//鱼类
class Fish extends Food{
	
	public void showName() {
		System.out.println("鱼");;
	}
}

//骨头类
class Bone extends Food{
	
	public void showName() {
		System.out.println("骨头");
	}
}

.............................
非多态演示：
喵喵叫
汪汪叫

多态演示
喵喵叫

狗吃骨头
骨头
猫吃鱼
鱼

附加

一、重载

1、简单的说，方法重载就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

2、注意事项：方法名相同；方法的参数类型、个数、顺序至少有一项不同；方法的修饰符和返回类型可以不同

3、演示

package face_to_object;

public class javabase_chongzai {

	public static void main(String[] args) {
		Compare com=new Compare();
		System.out.println(com.getMx(1, 2));
		System.out.println(com.getMax(34.5, 1.23));
		System.out.println(com.getMax(34.5, 1));
		System.out.println(com.getMax(6, 1.23));
		System.out.println(com.getMax(34, 1,23));
		
	}

}

class Compare{
	
	//返回类型不同
	public int getMx(int a,int b) {
		if(a>b) {
			return a;
		}
		else {
			return b;
		}
	}
	
	public double getMax(double a,double b) {
		if(a>b) {
			return a;
		}
		else {
			return b;
		}
	}
	
	//返回顺序不同
	public double getMax(int c,double d) {
		if(c>d) {
			return c;
		}
		else {
			return d;
		}
	}
	
		public double getMax(double c,int d) {
			if(c>d) {
				return c;
			}
			else {
				return d;
			}
	}
		
	//返回个数不同
	public int getMax(int i,int j,int k) {
		if(i>j) {
			if(j>k) {
				return i;
			}
			else {
				if(i>k) {
					return i;
				}
				else {
					return k;
				}
			}
		}
		else {
			if(j>k) {
				return j;
			}
			else {
				if(i>k) {
					return i;
				}
				else {
					return k;
				}
			}
		}
	}
}