封装和多态

1.封装：信息隐藏技术

2.封装技术主要用来存储信息，且类里面只有属性没有方法

3.任何访问类中私有成员变量的类都要通过get和set方法访问

封装：在面向对象程序设计中，封装（Encapsulation）是指，一种将抽象性函式接口

的实作细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装主要功能：我们修改自己的实现代码，而不用修改那些调用饿哦们代码的程序片段。

适当的封装可以让程序码更容易理解与维护，也加强了程序码的安全性。

 

public class EncapsulationTest{

    private String name;
    private int age;
    private String number;
    private boolean sex;

    //返回值sex
    public boolean isSex(){
        return sex;
}
    //赋值
    public boolean setSex(boolean sex){
        this.sex=sex;

}

    public String getName(){
        return;
}
    public String setName(String name){
        this.name=name;

}
    public int getAge(){
        return;
}
    public int setAge(int age){
        this.age=age;
}

    public String getNumber(){
        return;
}
    public String setNumber(String number){
        this.number=number;
}


}

/**
    在函数中怎么调用set  get方法
    创建一个Test类

*/
public class Test{

    public static void main(String[] atgs){
        EncapsuationTest s1 = new EncapsuationTest();
           s1.setSex("true");
           System.out.println(s1.isSex);
           s1.setName("张三");
           System.out.println(s1.getName);
}


}

多态

*多态的常用实现形式

         *父类作为方法的形参

         *父类作为方法的返回值

         *父类引用指向子类对象

Java的多态分为两种

          *静态多态。也叫编译时多态，通过方法重载实现

          *动态多态，运行时多态，通过对象的多态性实现

多态

      *一个引用类型变量如果声明为父类的类型，但实际指向的是子类对象，但是该对象就不能再访问

子类中独有的属性和方法

//school属于Student类中的属性

Student m = new Student();
m.school="郑大";      //合法

Person p = new Student();
p.school="郑大" ;    //不合法

         *当子类中重写了父类的方法，和父类拥有同名属性、方法时，方法将按照对象的运行时类型调用，属性将

按照对象的声明时类型调用。

             Animal a  =  new Cat();

             a.show();                           //将运行子类重写方法

              System.out.println(a.age);    //输出父类的属性值

多态代码

/*
    Animal为父类
*/

public class Animal {
	public String color;
	public String name;
	
	
	public Animal(){
		
	}
    public Animal(String color){
    	this.color=color;
    }
    public void eat(){
    	System.out.println("喜欢吃");
    }
    public String eat(String number){
    	System.out.println(number);
    	return number;
    }
    public void sleep(){
    	System.out.println("睡觉");
    	
    }
}

       

/**
    Cat为子类

*/

public class Cat extends Animal {
	
	public String eye;
	
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		super.sleep();
		System.out.println("一次睡五小时");
	}
	public void run(){
		System.out.println("跑的非常快");
		
	}

}

/*
   main 类
*/

public class Demo {
	public static void main(String[] args) {
		//静态多态
		Animal s1 = new Animal();
		s1.eat();
		s1.eat("一次吃20斤肉");
		Animal s2 = new Animal("balck");
		System.out.println(s2.color);
		
		
		//动态多态
		/*
		 * 写代码时，是编译时期。看等号左侧，声明的类型
		 *运行时期，是运行时期，看等号右侧，创建对象的类型、
		 * 
		 * 
		*/
		Animal s3 = new Cat();
		//s3.run();   ----->声明为父类的类型 所以该对象不能访问父类独有的方法和属性
		//s3.eye="亮亮的";  ----->错误同上
		s3.color="白色";   //---->调的是父类的属性
		s3.sleep();// ---->调的是子类中重写的方法
		
		
		
		Animal a = new Cat();
		text(a);
		
		
	}
		public static void text(Animal animal){
				System.out.println("引用数据类型，父类作为方法的形参");
		}
	   
		public Animal text1(){
			Animal b = new Animal();
            //Cat c = new Cat();
			return b;
		}
	
}