面向对象（封装，继承，多态）概念特征及代码案例

面向对象的三大特征

封装，继承，多态；

一，封装：

概念：将一个事物的属性,私有化(对外进行隐藏),外界不能直接访问(保证了数据安全性),需要提供对外的公共访问才可以访问成员变量!

案例：

/*
	private:私有的,外界无法访问的,只能在本类中访问
	this:代表了当前类的对象的地址值的引用
	将学生类进行改造
		将name,age属性私有化
		只能在本类访问,外界要访问,需要通过公共方法访问
		赋值/获取值  setxxx()getxxx() (成员方法)**	
*/

//定义一个学生类
class Student{
	//成员变量:name,age 私有化
	private String name ;
	private int age ;
	//提供对外的公共访问方法: 去掉static
	//给学生姓名赋值
	//this.成员变量   区分成员变量和局部变量
	public void setName(String n){ 
		this.name = n ;
	}
	//给学生年龄赋值
	public void setAge(int a){ 
	
		this.age = a ;
	}
	
	//获取学生的姓名
	public String getName(){
		return name ;
	}
	
	//获取学生的年龄
	public int getAge(){
		return age ;
	}
	
	
	
	//成员方法:学习
	public void study(){
		System.out.println("学习JavaSE_封装") ;
	}
}
//学生类测试类
class StudentTest{
	public static void main(String[] args){
		//创建一个学生类对象
		Student s = new Student() ;
		//公共访问:setXXX()赋值
		s.setName("xxx") ;
		s.setAge(25) ;
		//公共访问方法:getXXX()获取值
		System.out.println("姓名:"+s.getName()+";年龄:"+s.getAge()) ;
	}
}

二，继承（ extends）

1.概念：将多个类的共性内容抽取在一个独立的类中,然后独立的类和这些类产生一种"继承"关系

2.继承 特征 的好处:
提高了代码的复用性
提高了的代码的维护性
让类与类之间产生关系 ----- 是 "多态的前提条件"

案例：

//**使用继承的思想:将Student类和Worker类的共性共性内容:抽取到一个Person类中**
class Person{ //"父类"
	private String name ;
	private int age ;
	//无参构造
	public Person(){}
	//有参构造
	//构造方法赋值
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	
	//setXXX(xxx)方法
	public void setName(String name){
		this.name = name ;
	}
	public void  setAge(int age){
		this.age = age ;
	}
	//setXXX(xxx)方法
	public String getName(){
		return name ;
		
	}
	public int getAge(){
		return age ;
	}
	//定义特有功能
	public void eat(){
		System.out.println("饿了就需要eat") ;
	}
	public void sleep(){
		System.out.println("累了就需要sleep") ;
	}
}

//学生类和工人类 (子类)
class  Student extends Person{}
class  Worker extends Person{}

//测试类
class ExtendsDemo{

	public static void main(String[] args){
		//没有使用继承之前
		//创建一个学生类
		Student s = new Student("XXX",20) ;
		System.out.println(s.getName()+"---"+s.getAge()) ;
		s.eat() ;
		s.sleep() ;
		System.out.println("---------------------------") ;
		//创建工人类
		Worker w = new Worker("程序员",23) ;
		System.out.println(w.getName()+"---"+w.getAge()) ;
		w.eat() ;
		w.sleep() ;
		System.out.println("=======================================");
		//使用继承了
		//方式:通过无参+setXXX()
		//创建一个学生类
		Student s = new Student() ;
		s.setName("XXX") ; 
		s.setAge(20)  ;
		System.out.println(s.getName()+"---"+s.getAge()) ;
		s.eat() ;
		s.sleep() ;
		System.out.println("----------------------------------------");
		//创建工人类
		Worker w = new Worker() ;
		w.setName("XX") ;
		w.setAge(23) ;
		System.out.println(w.getName()+"---"+w.getAge()) ;
		w.eat() ;
		w.sleep() ;
	
	}
}

三，多态

1.概念： 一个事物在不同时刻体现的不同形态(内存中的变化)

2.多态的前提条件：
1)必须存在继承关系 (没有继承关系,不谈多态!)
2)必须有方法重写 (子类继承父类,需要将父类的功能覆盖掉) 使用子类的功能;
3)必须存在父类引用指向子类对象(“向上转型”)

3.多态中承运访问特点

• 非静态
  成员变量:编译看左,运行看左
  成员方法:编译看左,运行看右 :由于存在子类重写父类的功能,所以使用的子类的功能
  静态方法: 静态的东西都是跟当前类有关系:优先进内存(随着类的加载而加载)
• 静态方法
  算不上方法重写:编译看左,运行看左

4.多态的好处

• 可以提高代码的复用性 (是由继承保证的)
• 可以提高代码的扩展性(多态完成:父类引用指向子类对象:Fu f = new Zi()) ;

5.多态的弊端

• 不能访问子类的特有功能!

//父类
class Fu{
    public Fu(){
        System.out.println("这是父类的无参构造方法");
    }
    
    int num = 20 ;
    
    public void show(){
        System.out.println("show Fu");
    }

    //静态方法
    public static void function(){
        System.out.println("function Fu");
    }
}
//子类继承父类
class Zi extends  Fu{
    public Zi(){
        //super();默认存在，指向访问父类的地址值
        System.out.println("这是Zi类的无参构造方法");
    }
    int num = 30 ;
    //重写
    public void show(){
        System.out.println("show Zi");
    }

    //静态方法
    public static void function(){
        System.out.println("function Zi");
    }
}
//测试类
public class DuoTaiDemo {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Fu f = new Zi() ;  //向上转型
        System.out.println(f.num);
        f.show() ;
        f.function();
    }
}