面向对象的三大特性-----（个人理解）

封装

所谓封装就是将类的某些信息隐藏在内部，即属性私有化，不允许外部程序直接访问和修改，而是通过该类提供的方法来实现对内部的操作和访问。

例如：

类Student有性别、学号、姓名等属性，每个属性又有自己的方法.通过类Test检测，分配空间，调用Student的方法实现对其封装

优点：

只能通过规定的方法访问数据，不会随意更改属性和方法；
隐藏类的细节部分，方便修改和实现。


public class Student {
    private int id;
    private char sex;
    private String name;  //  属性私有    封装
    //构造函数
   //public Student() {}
   public Student(String name,char sex,int id) {
    	this.setName(name);
    	this.setId(id);
    	this.setSex(sex);
    }
   //有有参的构造函数就没有默认构造函数
    /*public void Study(int n) {
    	System.out.println("学习AJFDSVN");
    }*/
    
    public void Study() {
    	System.out.println("学习");
    }
    public void Prop(String name,char sex,int id){
    	this.setName(name);
    	this.setId(id);
    	this.setSex(sex);
    	
    }
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		if(sex == '男' || sex == '女') {
			this.sex = sex;
		}
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
public class Test {
public static void main(String[] args) {
		//Student s = new Student("kaka", '女',2132425);
		//Student s = new Student();
		//s.Prop("kak", '女', 1244546);
		//s.setName("试试");
		//s.setId(14325);
		//s.setSex('女');
		//System.out.println(s.getName() + ":" + s.getSex() + ":" + s.getId())	
	}
}

继承

继承是子类和父类的关系，是一种 “is a” 的关系，Java的继承是单继承，一个类只有一个父类。子类拥有父类的所有属性和方法，除了私有属性。

例如：

类college 继承了student的所有方法和属性


public class College extends Student {
/*
 * 子类继承父类所有方法  通过重写添加自己的功能
 * 子类没有构造函数的时候 编译器自动生成一个构造函数 
   子类的构造函数必须调用父类的构造函数
 */
	private int subject;

    public void Study() {
    	super.Study();
    	System.out.println("software");
    	System.out.println("math");
    	System.out.println("English");
    }  // 重写
    // 功能扩展  父类没有 子类重新创造方法
    public void shijian() {} 
	public College() {
		super("fkdsg",'女',143453);  // 子类调用父类构造函数
		//super();   // 无参的 、 默认的构造函数
	}
	
	public int getSubject() {
		return subject;
	}
	public void setSubject(int subject) {
		this.subject = subject;
	}
	
	public class Test1 {
	public static void main(String[] args) {
		Student s =new Student("kaka",'女',1435);
		//Student s =new Student();
		/*
		 * s类变换成c类，s可调用c类继承下来的方法，但c类重写的方法无法引用调用
		 * 重写调用子类
		 */
		s.Study();
		College c = new College();
		c.Study();
		s = c;  // 多态   父类的引用可以保存子类的地址
		s.Study();//调用子类
		//s.setName("kak");  // 构造函数优先
		s.setSex('女');
		//s.Study();  // 子类的构造函数的调用
		//s.Study();
		c.setSubject(14325);
		//c.Study();
		System.out.println(s.getName());

	}

}
}

优点：子类拥有父类的所有属性和方法，除了私有属性。

多态

多态就是对象的的多种形态，父类的引用可以保存子类的地址，父类的引用既可以指向本类的对象，也可以指向子类的对象。

例如：

public abstract class Person {
   private String name;
   public Person(String name) {
	   this.name = name;
   }
   public void eat(Food c) {
	   System.out.println(this.name + "吃" + c.getName());   
   }   
   public String getName() {
	return name;
}

   public void setName(String name) {
	this.name = name;
}
    public abstract void speak();   //抽象方法
}

public class Chicken extends Food {
	public Chicken() {
		super.setName("麦香全鸡块");
	}
}

public class Duck extends Food {
	public Duck() {
		super.setName("北京烤鸭");
	}
}
public class Fish extends Food{
	public Fish() {
		super.setName("咸鱼");
}

public abstract class Food {
	private String name ;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

public class TestDuotai {

	public static void main(String[] args) {
	   
		Person s = new 美国人("示范");//new 父类的子类   子类继承父类    父类抽象化
		Chicken c = new Chicken();
		//Food f = new Food(); 
		Duck d = new Duck();
		Fish f = new Fish();
		//Food aa= new Food();
		//s.eat(aa);                  // 无意义 
		s.eat(c);
		s.eat(d);
		s.eat(f);
	}
}

面向对象的三大特性-----（个人理解）

猜你喜欢