面向对象——三大特征

面向对象——三大特征

1. 封装

封装是把客观事物抽象成类，并且把自己的属性和方法让可信的类或对象操作，对不可性的隐藏。

封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

实现java封装：

1.修改属性的可见性来限制对属性的访问（一般限制为private）。
例如：

public class Person {
    private String name;
    private int age;
}

2.对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。
例如：

public class Person{
    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;
	}
}

3.访问私有的变量
例如：

public class doing{
	public static void main(String[] args){
		Person person = new Person();
		person.setAge(18);
		person.setName("faye");
		System.out.println("她是"+ person.getAge()+ "岁的"+ person.getName());
		}
}

输出结果:

 她是18岁的faye

`

2. 继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的好处：

• 继承的出现提高了代码的复用性，提高软件开发效率。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

类的继承格式:

class 父类 {
}
 
class 子类 extends 父类 {
}

例如:

//父类
public class people {
	    private String name;  
	    private int age; 
	    
	    public people(String myName, int myage) { 
	        this.name = myName; 
	        this.age = myage;
	    } 
	    public void eat(){ 
	        System.out.println(name+"正在吃"); 
	    }
	    public void sleep(){
	        System.out.println(name+"正在睡");
	    }
	    public void introduction() { 
	        System.out.println("我是"+ age +"岁的"+ name +"."); 
	    } 
		
}

//子类faye
public class faye extends people{
	
	public faye(String myName, int myage) {
		super(myName,myage);
	}
}

//子类spike
public class spike extends people{

	public spike(String myName, int myage) {
		super(myName, myage);
	}
}

//调用
public class test {
	public static void main(String[] args) {
		faye faye = new faye("faye",18);
		spike spike = new spike("spike",81);
		faye.eat();
		faye.sleep();
		faye.introduction();
		spike.eat();
		spike.sleep();
		spike.introduction();
		
	}
}

运行结果:

faye正在吃
faye正在睡
我是18岁的faye.
spike正在吃
spike正在睡
我是81岁的spike.

3. 多态

一个事务的多种状态;多态是在继承的基础上存在的，父类引用指向子类实例！！

多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态存在的三个必要条件:继承 ; 重写 ; 父类引用指向子类对象:Parent p = new Child();

例如：

public class people {
    void doing(){
        System.out.println("eat");
    };
    void appearance(){
        System.out.println("normal");
    };
}
class faye extends people{
        public void doing() {
            System.out.println("爱好赌博");
        }
        public void appearance() {
            System.out.println("非常美");
        }
        public void age(){
            System.out.println("18");
        }
}
class spike extends people{
        public void doing() {
            System.out.println("做赏金猎人");
        }
        public void appearance() {
            System.out.println("有点小帅");
        }
}
class does{
    public static void main(String[] args) {
        people people1 = new faye();
        people1.appearance();
        people people2 = new spike();
        people2.appearance();
    }
}

运行结果：

非常美
有点小帅