封装
概念:
在程序中简单理解封装就是把代码整合到一起! 函数的封装:就是把一组操作整合到一起;类的封装:就是把属性和方法整合到一起;结构的封装:根据操作的性质(模型/控制操作/交互视图)进行结构设计封装。
具体操作:
属性设置为private
提供getter和setter
基本类型的封装:Java中要保证所有的成员都是完全面向对象的,所以java为基本数据类型也设计了一套对象类型(单词一致,首字母大写)
byte -- Byte
short-Short
int-Integer
long-Long
float-Float
double-Double
char-Character
boolean-Boolean
实际项目开发中, javabean中的成员(属性)的类型要求用封装类型
封装的目的:
封装解决程序的安全性问题。
狭义:用private声明字段,用public方法来声明bean方法,形成了JavaBean(user)。
广义:要将保护的成员都声明为私有,用封装公共方法对外提供访问操作。
继承
我们发现,一个B类中的操作都实用于另一个类A,但另外一个类还多出一些个性方法,我们希望既有类操作,又能拓展个性化重要的需要由此产生了继承。
具体操作
class Father{}
class Son ==extends== Father{}
extend: 得到,拓展 , java使用了动词形式 extends
public class Father {
//父类 姓名和年龄属性
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Father(String name, Integer age) {
this.name = name;
this.age = age;
}
public Father() {
}
//公共的方法
public void f1() {
System.out.println(name+"今年"+age+"岁了");
}
}
//子类
public class Sun extends Father{
//拥有自己的字段
private String money;
public String getMoney() {
return money;
}
public void setMoney(String money) {
this.money = money;
}
public Sun(String name, Integer age, String money) {
//super 实际上就是对父类成员的调用
super(name, age);
this.money = money;
}
public Sun() {
super.f1();
}
}
public class Main {
public static void main(String[] args) {
//实例化父类,并调用其方法
Father father=new Father("张三",40);
father.f1();
//实例化子类,并调用父类的方法
Sun sun=new Sun("张小二",18,"500");
sun.f1();
}
}
结果: 张三今年40岁了
张小二今年18岁了
以上代码段我们用了在继承的基础上同时运用了封装的思想,子类无法直接访问父类中的name属性和age,但子类却可以通过继承父类的构造方法super(),来完成调用与赋值,同时也调用了父类的方法,当然子类也可以重写@Override父类的方法 来展现自生的一个独特性。
@Override
public void f1() {
System.out.println(this.getName()+"今年"+this.getAge()+"岁了"+money);
}
//输出的结果:张小二今年18岁了,挣了500元
作用
Son:子类,派生类(subClass)。
Father: 父类,超类,基类(superClass)。
子类通过继承父类,得到了父类中的非私有的成员的访问。
继承解决程序的重用性的问题,可以有效的降低重复性代码。
注意:
单继承:父类可以派生多个子类,但子类只能有一个父类,不能双向继承。
调用顺序:继承不能直接调用目标类中的私有成员。
Object:所有类的根父类都被java指定为Object类。
多态
简单理解就是多种形态(对象、方法、属性等),既有存在的多种形态也有调用的多种形态
方法的多态。
重载:
在一个类中,存在一组方法,它们的方法名一致,但参数各不相同(数量或类型),这一组方法就构成了重载,用单词Overload表示。
作用:同一个方法可以通过不同的参数来达到不同的效果,例如我们常见的println()。
注意:重载和返回值无关, 构造方法、实例方法都可以实现重载。
重写:
在继承过程中,如果子类声明了一个方法,和父类的方法声明完全一致,只有操作不同,父类和子类的方法就构成了重写。
作用: 让子类和父类具有相同的行为,但,执行方式却不同,为对象的多态准备。
注意:用单词Override表示,也被叫做覆盖,重写时,方法的声明部分(访问权限/返回类型/参数/方法名)都必须完全一致,子类访问权限可以小于等于父类。
对象的多态
声明为高级类型(父类),传递引用的时候赋值为低级类型(子类), 声明对象就是上转型对象;上转型对象在执行到有重写的方法时,会执行子类(重写);上转型对象可以调用父类中声明的方法(继承);上转型对象不可以调用子类独有的方法。
//动物父类
public class Animal {
public void shout() {
System.out.println("动物的吼叫");
}
@Override
public String toString() {
return "不知名的生物";
}
}
//猫子类
public class Cat extends Animal{
// 子类独有的方法
public void eatFish() {
System.out.println("吃鱼");
}
// 重写父类的方法
public void shout(int i) {
System.out.println("喵喵喵");
}
@Override
public String toString() {
return "大橘";
}
}
//上转型具体操作
public static void main(String[] args) {
// 养了一群小动物
Animal[] animals = new Animal[3];
// 添加小动物
animals[0] = new Animal();//动物的实例
animals[1] = new Cat(); //猫的实例实际上就是上转型
下转型对象:声明低级子类,传递引用时赋值给高级父类,在这里设计到封箱拆箱思想,在转化时我们会用到强转;
// 声明的类型是父类类型, 实例化使用的是子类的构造
// a就叫做上转型对象
Animal a = new Cat();
Object o = new Cat();
// 利用上转型对象,在集合List设置为可以添加任意类型
List<Object> list = new ArrayList<Object>();
list.add(1);
list.add("abc");
list.add(a);
list.add(o);
// 上转型对象调用子类独有的方法, 不能
// 只能调用父类的或重写的方法
// a.eatFish();
// 本质上是一个父类对象,强转为子类对象(下转型)可以编译通过,
//但执行就会抛出异常:ClassCastException
/*
* Animal animal = new Animal(); ((Cat)animal).eatFish();
*/
// 安全的下转型操作: 判断实例化时的对象类型
Animal animal2 = new Cat();
((Cat)animal2).eatFish();
多态的使用思想
先构建父子的类型的体系;在使用类型的时候用父类作为高级的类型声明(兼容性,拓展);只要声明新的子类类型,它和原有操作就完全兼容。
最后提及多态我们不得不谈到抽象abstract、接口interface,后续我会用专门的文章进行进行讲解!!!看过的铁子们,觉得博主讲的还可以留下一个珍贵的赞吧!小白博主做这些真的不容易,希望大家鼓励鼓励!