JavaSE学习(6) 面向对象类和对象（4）三大特性

Java面向对象编程三大特征：封装、继承、多态

抽象：

  定义一个类，实际是把一类事物的共有的属性和行为提取出来，形成一个物理模型（模板）。

封装：

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

访问控制修饰符

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

1）公开级别：public ，对外开放

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

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

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

 访问级别：   访问控制修饰符   同类 同包 子类不同包

 公开 public                        可以可以可以 可以

受保护 protected可以可以 可以 不可以

默认 没有修饰符可以可以 不可以 不可以

私有 private可以不可以 不可以不可以

包（package）--必要性

三大作用：

1）区分相同名字的类

2）当类很多时，可以很好的管理类

3）控制访问范围

包--打包命令

package com.xiaohuzi

包的命名规范

小写字母  比如  com.china.xiaohuzi

包-常用的包

一个包下，包含很多个类，java中常用 的包有：

java.lang.*包   自动引入         java.util.* 工具包

java.net.*       网络开发包              java.aw.*包 窗口工具包

如何让引入包？

import 包;

示例：import java.awt.*;

引入一个包的主要目的是使用该包下的类

继承：

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

class  子类 extends   父类

这样，子类就会自动拥有父类定义的属性和方法

示例：

package com.chenchen;
/*
 * 功能：说明继承的重要性
 * */
public class Demo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Pupil p1=new Pupil();
		p1.printName();
	}

}
//将学生的共有属性提出，做一个父类
class Stu{
	//定义成员属性
		public int age;
		public String name;
		public float fee;
		public void printName(){
			System.out.println("名字："+this.name);
		}
}
//小学生
class Pupil extends Stu{
	//定义成员属性
	
	//交学费
	public void pay(float fee){
		this.fee=fee;
	}
	
}
//中学生类
class MiddleStu extends Stu{
//定义成员属性
	
	
	//交学费
	public void pay(float fee){
		this.fee=fee*0.8f;
	}
}
//大学生类
class ColStu extends Stu{
//定义成员属性

	
	//交学费
	public void pay(float fee){
		this.fee=fee*0.1f;
	}
}

注意事项：

1）子类最多只能继承一个父类（直接继承）

2）java所有的类都是Object类的子类

方法重载：

方法重载（overload）和方法覆盖（override）

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

注意事项：

1）方法名相同

2）方法的参数名、个数、顺序至少有一项不同

3）方法返回类型可以不同

4）方法的修饰符可以不同

如果只是返回类型不同，不能构成重载！！

如果只是修饰符不 同，不能构成重载！！

package com.xxx;

import javax.swing.*;

public class Demo2 extends JFrame {
	public static void main(String []args){
		//Demo2 demo2=new Demo2();
		Abc abc=new Abc();
		System.out.println(abc.getMax(3, 4));
	}
	/*public Demo2(){
		this.setVisible(true);
		this.setSize(400,400);
	}*/
}
class Abc{
	//返回较大的整数
	public int getMax(int i,int j){
		if(i>j){
			return i;
		}else{
			return j;
		}
	}
	public float getMax(float a,float b){
		if(a>b){
			return a;
		}else{
			return a;
		}
	}
	public float getMax(double c,float d){
		if(c>d){
			return (float)c;
		}else{
			return (float)d;
		}
	}
	public float getMax(float d,double c){
		if(c>d){
			return (float)c;
		}else{
			return (float)d;
		}
	}
	//如果只是返回类型不一样，能否构成重载：不能！！！
	/*public double getMax(float d,double c){
		if(c>d){
			return (float)c;
		}else{
			return (float)d;
		}
	}*/
	//如果只是控制访问修饰符不同，能否构成重载：不能！！！
	/*private double getMax(float d,double c){
	if(c>d){
		return (float)c;
	}else{
		return (float)d;
	}
}*/
}

方法覆盖：

子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，这就是方法的覆盖

1)子类的方法的返回类型，参数，方法名称，要和父类方法的返回类型，参数，方法名称完全一样，否则编译通不过

2)子类方法不能缩小父类访问方法的访问权限,反之可以。

package com.xxx;

public class Demo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一只猫
		Cat cat1=new Cat();
		cat1.cry();
		Dog dog1=new Dog();
		dog1.cry();
	}

}
class Animal{
	int age;
	String name;
	//都会叫
	public void cry(){
		System.out.println("我是动物不知道怎么叫唤！");
	}
	
}
//猫猫类
class Cat extends Animal{
	//覆盖父类
	public void cry(){
		System.out.println("喵喵！");
	}
	
}
//狗狗类
class Dog extends Animal{
	//覆盖父类
	public void cry(){
		System.out.println("汪汪！");
	}
	
}

多态：

-指一个引用（类型）在不同情况下的多种状态。

通过指向父类的指针，来调用在不同子类中实现的方法。

多态注意类型的转换

1）java允许父类的引用变量引用她的子类对象-----自动完成！

/*
 * 演示多态
 * */
package com.xxx;

public class Demo5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//多态
		/*Cat1 cat=new Cat1();
		cat.cry();
		Dog1 dog=new Dog1();
		dog.cry();*/
		/*Cat1 cat=new Cat1();
		 * Animal1 an=new Cat1();
		an.cry();
		an=new Dog1();
		an.cry();*/
		Master master=new Master();
		master.feed(new Dog1(), new Bone());
	}
}
//主人类
class Master{
	//给动物喂食物，使用多态，方法就可以用一个
	public void feed(Animal1 an,Food f){
		an.eat();
		f.showName();
	}
}
class Food{
	String name;
	public void showName(){
		
	}
}
class Fish extends Food{
	public void showName(){
		System.out.println("鱼！");
	}
}
class Bone extends Food{
	public void showName(){
		System.out.println("骨头！");
	}
}
//动物类
class Animal1{
	private String name;
	private 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 Dog1 extends Animal1{
	//狗自己叫唤
	public void cry(){
		System.out.println("汪汪叫");
	}
	//狗吃东西
	public void eat(){
		System.out.println("狗喜欢吃骨头！");
	}
}
class Cat1 extends Animal1{
	//猫自己叫唤
	public void cry(){
		System.out.println("喵喵叫");
	}
	//猫吃东西
	public void eat(){
		System.out.println("猫喜欢吃鱼！");
	}
}

补充：如果希望在子类中去调用父类的构造方法，要求在子类的构造函数中调用

public class Test4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Kkk kk=new Kkk(1, "cc");
	}

}
class Base{
	int age;
	String name;
	public Base(int age,String name) {
		// TODO Auto-generated constructor stub
		System.out.println("Base");
		this.age=age;
		this.name=name;
	}
}
class Kkk extends Base{
	public Kkk(int age,String name){
		
		super(age,name);
	}
}