Java Class07

Java Class07

封装

封装就是将信息进行密封包装，对外界的访问只能通过给定的方法

封：就是将属性private的过程
装：就是将属性放入方法的过程

在代码中，通常一个类就是一个模块，在模块与模块之间如果过于复杂将会使得模块之间可以互相修改数据而导致不安全

所以封装的设计可以实现类内的强内聚，弱耦合，所有应当实现的功能要尽可能在类内实现，在类与类之间尽可能的减少关系

public class Student {
    String name;//定义姓名
    String sex;//定义性别
    int grade;//定义年级
    int age;//定义年龄
    String getName(){//取名字
        return name;
    }

    void setName(String name1){//设置名字
        name=name1;
    }

    String getSex(){//取性别
        return sex;
    }

    void setSex(String sex1){//设置性别
        sex=sex1;
    }

    int getGrade(){
        return grade;
    }

    void setGrade(int grade1){
        grade=grade1;
    }

    int getAge(){
        return age;
    }

    void setAge(int age1){
        age=age1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

优点：可以提高安全性，保障数据完整性，增强代码可维护性

继承

继承就是将类进行复用的过程，可以减少代码重复编写。

继承实际是扩展的概念，就是将已有的类进行填充的过程

C++采用多根继承，Java只有单根继承，Java在继承更简单但也适配性更低，无法完成多继承的内容（使用接口来实现多继承）

子类角度是继承
父类角度是派生

public class Son extends Father {//定义子类B7继承父类B0
    void to(){//定义子类独有方法

    }

    public static void main(String[] args) {
        Son son=new Son();//实例化子类对象
        son.ok();//对象调用子类继承父类方法
        son.to();//对象调用子类独有方法
    }
}

class Father{//定义父类B0
    void ok(){//定义父类方法

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

优点：在代码中的模块可以被直接复用，使得代码更具有层次感，扩展性，为多态的使用奠定基础

缺点：如果滥用继承，会导致继承层次过深，如果继承关系复杂，会导致代码安全性降低

子类在继承父类方法时，会先调用父类下的方法去实现，然后才会实现子类自己的方法

public class E7 extends E70 {
    E7(){
        System.out.println("自己");
    }

    public static void main(String[] args) {
        new E7();
    }
}

class E70 extends E700 {
    E70(){
        System.out.println("父亲");
    }
}

class E700{
    E700(){
        System.out.println("爷爷");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

聚合
belong to
属于has a的关系，也就是拥有关系，例如人和电脑的关系就是has a，即我有一个电脑，但我两个之间并不会存在一个坏了影响另一个的事情

public class Computer {

}

class People{
    private Computer computer;
    public void UseComputer(){
        computer=new Computer();
    }
}

1
2
3
4
5
6
7
8
9
10
11

组合
属于is a的关系，也就是从属关系，例如人和大脑之间的关系就是is a，即我有一个脑袋，但是如果任意一个坏死了就会影响到另一个

public class Body {

}

class Person{
    private Body body;
    public Person(){
        body=new Body();
    }
}
 
1
2
3
4
5
6
7
8
9
10
11

重载
重载就是类中的方法名称相同，方法的返回值类型，个数，顺序都不尽相同

public class Demo{
	public int age;
	public int height;
	public void go(int age,int height){
	}
	
	public void go(int age){	
	}
}
1
2
3
4
5
6
7
8
9

重写
重写是用在继承之间，子类复写父类方法的过程

public class A{
	@Override
	public void method(){
		System.out.println("重写方法");
	}
}

class B{
	public void method(){
		System.out.print("原有方法");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12