有时候, 代码写的不少, 但有些术语却总是记得不太清楚; 有些原理, 明明经常用到, 但却不太会描述既然如此, 那就记录下来, 印象不深的时候再来看看
1. 封装: 把对象的属性操作 (或业务) 结合为一个整体(class), 并尽可能得隐藏内部实现细节, 使得对数据的访问只能通过已定义的接口
- public class Person {
- private String name = "张三";
- private int age = 18;
- 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;
- }
- public void eat(){
- System.out.println("人要吃东西");
- }
- }
上述代码中, 把姓名年龄属性和吃饭行为都封装到 person 类中的做法, 叫做是封装
2. 继承: 从已有的类中派生出新的类, 新的类能吸收已有类中的属性与方法, 并能拓展新的能力被继承的类称之为父类或基类, 派生出的新类称之为该类的子类
重写: 子类对从父类继承而来的方法进行修改, 返回值和形参都不能改变(可以用注解 @override 来校验重写是否成功), 子类重写的方法不属于新增的方法, 重写又叫做覆盖特别注意, 父类的成员变量和静态变量不会被重写, 仅仅会被隐藏, 被隐藏的变量无法被访问
- public class Son extends Person {
- // 私有属性无法被继承
- private int age = 1;
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- // 重写父类方法
- @Override
- public void eat() {
- System.out.println(this.getAge() + "岁的儿子" + this.getName() + "说: 爸爸, 我饿");
- }
- }
- public class Test {
- // 测试方法 1
- @org.junit.Test
- public void test1() throws Exception {
- Son son = new Son();
- son.eat();
- }
- }
执行结果: 1 岁的儿子张三说: 爸爸, 我饿
上述代码中, 父类 name 属性被子类继承, 所以执行结果中, 儿子也叫做张三而 eat()方法被重写, 子类对象调用的是重写后的 eat()方法
3. 重载: 在一个类中存在多个方法名称相同, 但参数签名不同(参数的个数或者类型不同)(修饰符返回值类型可以相同也可以不同)
- public class Reload {
- public static void reload(){
- System.out.println("无参重载方法");
- }
- public void reload(String s){
- System.out.println("string 参数重载方法");
- }
- public void reload(String s, int i){
- System.out.println("string,int 参数重载方法");
- }
- protected String reload(int i){
- System.out.println("int 参数重载方法");
- return "";
- }
- }
- public class Test {
- @org.junit.Test
- public void test2() throws Exception {
- Reload reload = new Reload();
- reload.reload();
- reload.reload("");
- reload.reload("",1);
- reload.reload(1);
- }
- }
执行结果:
无参重载方法
string 参数重载方法
string,int 参数重载方法
int 参数重载方法
4. 多态: 允许不同类的对象对同一消息做出响应即同一操作作用于不同的对象, 可以有不同的解释, 产生不同的执行结果这也意味着一个对象有着多重特征, 可以在特定的情况下, 表现不同的状态, 从而对应着不同的属性和方法
多态的实现方式: 接口实现, 继承父类进行方法重写, 同一个类中进行方法重载
- public class Person {
- private String name = "张三";
- private int age = 18;
- public Person(){
- System.out.println("父类的无参构造器:" + this.getName() + "今年" + this.getAge() +"岁");
- this.eat();
- }
- 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;
- }
- public void eat(){
- System.out.println("人要吃东西");
- }
- }
- public class Son extends Person {
- // 私有属性无法被继承, 因为此变量名在父类中存在, 故父类中此变量将被隐藏
- private int age = 1;
- public static String addr = "abc";
- public Son(){
- // 在执行子类的构造方法之前, 必定先调用父类的构造器, 若无显示, 则默认调用 super()
- // 默认: super();
- System.out.println("子类的无参构造器:" + this.getName() + "今年" + this.getAge() +"岁");
- }
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- // 重写父类方法
- @Override
- public void eat() {
- System.out.println(this.getAge() + "岁的儿子" + this.getName() + "说: 爸爸, 我饿");
- }
- }
- public class Test {
- @org.junit.Test
- public void test3() throws Exception {
- Person person = new Son();
- person.eat();
- }
- }
执行结果:
父类的无参构造器: 张三今年 0 岁
0 岁的儿子张三说: 爸爸, 我饿
子类的无参构造器: 张三今年 1 岁
1 岁的儿子张三说: 爸爸, 我饿
定义父类引用指向子类对象, 在创建子类对象时, 步骤:
1 首先会隐式调用父类无参构造器, 于是先打印了父类的无参构造器: 张三今年 0 岁而为何是 0 岁而不是 18 岁的原因, 是子类中存在 age 变量与父类同名, 故父类的 age 变量被隐藏 2 而在父类构造器中调用了 this.eat(), 实际调用的还是子类重写后的方法 (毕竟调用对象都是子类对象, 仅仅引用类型为父类而已),3 接着 super() 构造器执行完成 (作用是初始化父类变量和方法等), 开始执行子类构造器(先初始化子类变量),4 调用子类 eat() 方法
来源: http://www.bubuko.com/infodetail-2520816.html