三大特性的学习笔记

三大特性的学习笔记

三大特性:封装丶继承丶多态
封装
故名思意把一个东西包装起来,尽可能隐藏对象的内部实现细节,控制对象的修改及访问权限,使属性私有化,不对外提供访问,通过set/get方法进行封装,好处使过滤不合理数据,保证数据的完整性.

//案例演示:
class Test{
private int age;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}

继承
继承是类与类之间特征和行为的一种赠与或获得,两个类之间的继承关系,必须满足"is a"的关系.在一组相同或类似的类中,抽取出共性的特征和行为,定义在父亲中,实现重用.
关键字:extends

//创建dog、cat、bird、snake，并抽取属性方法为父类Animal并继承,运行测试子类方法和父类方法

public class Test{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog d = new Dog();
		d.name = "小黄";
		d.age = 5;
		d.sex = "男";
		d.eat();
		d.sleep();
		d.wan();
		System.out.println("我是一只狗,我的名字叫" + d.name + ",我有" + d.age + "岁,我的性别是" + d.sex);
		System.out.println("");

		Cat c = new Cat();
		c.name = "小白";
		c.age = 5;
		c.sex = "女";
		c.eat();
		c.sleep();
		c.play();
		System.out.println("我是一只猫,我的名字叫" + c.name + ",我有" + c.age + "岁,我的性别是" + c.sex);
		System.out.println("");

		Bird b = new Bird();
		b.name = "小黑";
		b.age = 5;
		b.sex = "男";
		b.eat();
		b.sleep();
		b.fly();
		System.out.println("我是一只鸟,我的名字叫" + b.name + ",我有" + b.age + "岁,我的性别是" + b.sex);
		System.out.println("");
		

		Snake s = new Snake();
		s.name = "小彩";
		s.age = 5;
		s.sex = "男";
		s.eat();
		s.sleep();
		s.pa();
		System.out.println("我是一条蛇,我的名字叫" + s.name + ",我有" + s.age + "岁,我的性别是" + s.sex);
		System.out.println("");

	}

}

class Animal {
	String name;
	int age;
	String sex;

	public void eat() {
		System.out.println("吃东西");
	}

	public void sleep() {
		System.out.println("睡觉");
	}
}

class Dog extends Animal {
	public void wan() {
		System.out.println("摇尾巴");
	}
}

class Cat extends Animal {
	public void play() {
		System.out.println("玩球");
	}
}

class Bird extends Animal {
	public void fly() {
		System.out.println("在天上飞");
	}

}

class Snake extends Animal {
	public void pa() {
		System.out.println("在地上爬");
	}
}

继承的特点: Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。
不可继承的有: 构造方法丶private修饰的属性和方法丶父子类不在同一个package中时，default修饰的属性和方法
访问修饰符

方法的重写
方法重写原则:
1.方法名称、参数列表与父类相同
2.返回值类型必须与父类相同或其子类
3.访问修饰符可与父类相同或是比父类更宽泛
方法重写的执行:
1.子类重写父类方法后，调用时优先执行子类重写后的方法。
2.方法重写的特性：
Ø 子类重写父类方法时子类方法会覆盖父类方法。
Ø 子类重写父类方法，访问级别不能严于父类方法。
Ø 子类重写方法名和类型与父类一样。
Ø 父类的构造方法无法重写，只能被覆盖。

public class TestOverride {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();//狗在吃骨头（覆盖后，优先执行子类覆盖之后的版本）
Cat cat = new Cat();
cat.eat();//猫在吃鱼
	}
}
class Animal{
String breed;
int age;
String sex;
public void eat() {
System.out.println("动物在吃...");
	}
public void sleep() {
System.out.println("动物在睡...");
	}
}
class Dog extends Animal{
String furColor;
//子类中定义和父类相同的方法进行覆盖
public void eat() {
System.out.println("狗在吃骨头...");
	}
	
public void sleep() {
System.out.println("狗在趴着睡...");
	}
public void run() {
		
	}
}
class Cat extends Animal{
	
}
class Fish extends Animal{
	
}

方法重写与重载的异同

方法重载:
1.方法名相同
2.参数列表不同→数据类型,个数,顺序
3.和访问修饰符与返回值无关
方法重写:和父类一致
1.方法名相同
2.参数列表相同→数据类型,个数,顺序
3.访问修饰符和父亲相同或更宽(不能比父亲更严)
4.返回值和父亲一样,或其子类(返回值类型的子类)

相同点:
方法名相同
不同点
重载:参数列表不同,返回值访问修饰符无关
重写:参数列表相同,返回值相同或其子类,访问修饰符不能比父类更严

多态
多态的概念:
1.父类引用指向子类对象,即形成多态.
2.父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

public class TestBasicPolymorphic {
public static void main(String[] args) {
Animal a = new Dog();//将狗对象，当成动物来看待
System.out.println(a.breed);
System.out.println(a.age);
System.out.println(a.sex);
a.eat();
a.sleep();
		
Dog d = new Dog();//将狗对象，当成狗来看待
System.out.println(d.breed);
System.out.println(d.age);
System.out.println(d.sex);
System.out.println(d.furColor);
d.eat();
d.sleep();
d.run();
		
	}
}

class Animal{
String breed;
int age;
String sex;
	
public void eat() {}
public void sleep() {}
}

class Dog extends Animal{
String furColor;
	
public void run() {}
}

多态的装箱丶拆箱

向上转型(装箱):父类引用中保存真实子类对象，称为向上转型

//案例说明
public class Test{
public static void main(String[] args){
Animal a=new Dog();
a.eat();

}
}
class Animal{
public void eat(){
System.out.println("动物在吃...");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗在吃骨头...");
}
}

向下转型(拆箱):将父类引用中的真实子类对象,强转回子类本身类型,称为向下转型.

//案例
public class Test{
public static void main(String[] args){
Animal a = new Dog();
Dog dog = (Dog)a;
a.eat();

}
}
class Animal{
public void eat(){
System.out.println("动物在吃...");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗在吃骨头...");
}
}

类型转换异常:向下转型时,如果父类引用中的子类对象类型和目标类型不匹配,则会发生类型转换异常.

//案例
class Animal{
public void eat(){
System.out.println("动物在吃...");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗在吃骨头...");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("狗在吃骨头...");
}
}
public class Test{
public static void main(String[] args){
Animal a = new Dog();
Cat cat = (Cat)a;//则会编译异常
//Exception in thread "main" java.lang.ClassCastException


}
}

instanceof关键字
1.向下转型前,应判断引用中的对象真实类型,保证类型转换的正确性.
2.语法:父类引用instanceof类型//返回boolean类型结果

//案例-接上面案例
public class Test{
public static void main(String[] args){
Animal a = new Dog();
if(a instanceof Dog){
//当"a"引用中存储的对象类型确实为Dog时,在进行类型转换,进而调用Dog中的独有方法
Dog dog = (Dog)a;
dog.eat();
}
else if(a instanceof Cat){
Cat cat = (Cat)a;
cat.eat();
}
}
}