Java之三大特性

Java之三大特性

1.封装

即是为了保护属性，对外只暴露想暴露的方法，实现保护数据的目的。低耦合 高内聚
一般表现为：spring（java框架体系）中bean属性的get/set方法（IDEA快捷键Alt+Insert）

package com.oop.demo02;

// 封装 保护属性 对外只暴露想暴露的方法
// 低耦合 高内聚
// 保护数据
public class Student {
    private  String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    // 封装
    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;
    }
}

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

package com.oop.demo02;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("大鹏");
        student.setAge(6);

        System.out.println(student.getName()+"今年"+student.getAge()+"岁"); // 大鹏今年6岁

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

2.继承

即子类继承父类 ，表示类与类之间的关系 。 若有final修饰则无法被继承
关键词：extends

子类：派生类 父类：基类
子类继承父类 拥有父类的所有方法以及属性 private除外
Java只能是单继承 即 一个爸爸多个儿子

重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法

Java中 所有的类都间接或直接继承Object类

Person 类与Student类展示super用法,A类与B类展示父子类重写，Application类为启动类

package com.oop.demo03;

// 继承 子类继承父类  类与类之间的关系  关键词：extends
// 子类：派生类   父类：基类
// 子类继承父类 拥有父类的所有方法以及属性  private除外
// Java只能是单继承  即 一个爸爸多个儿子

// 重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法

// Java中 所有的类都间接或直接继承Object类
public class Person {
    public Person(){
        System.out.println("父类无参构造");
    }
    public int money = 10000;

    public void method1(){
        System.out.println("父类的方法");
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.oop.demo03;

public class Student extends Person{
    public Student(){
        // 子类调用父类无参构造 只能写第一层
        super();// 父类无参构造
        System.out.println("子类无参构造"); // 子类无参构造
    }

    public void method1(){
        // 子类使用super调用父类的属性
        System.out.println("子类使用super调用父类的属性"+ super.money); // 子类使用super调用父类的属性10000
        // 子类使用super调用父类的方法
        super.method1(); // 父类的方法
    }
}

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

实现在Appcation类中

package com.oop.demo03;

public class A {
    public static void test(){
        System.out.println("打印A");
    }

    public  void test1(){
        System.out.println("打印A");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

package com.oop.demo03;

public class B extends A{
    public static void test(){
        System.out.println("打印B");
    }

    public  void test1(){
        System.out.println("打印B");
    }
}
1
2
3
4
5
6
7
8
9
10
11

package com.oop.demo03;

public class Application {
    public static void main(String[] args) {
        method3();
        Application application = new Application();
        application.method2();
    }

    // 继承的实现方法
    private void method1(){
        Student student = new Student();
        // 实例化对象调用父类的属性
        System.out.println("实例化对象调用父类的属性"+student.money); // 实例化对象调用父类的属性10000
        // 实例化对象调用子类的方法
        student.method1();

        // 父类无参构造
        // 子类无参构造
        // 实例化对象调用父类的属性10000
        // 子类使用super调用父类的属性10000
        // 父类的方法

    }

    // 重写
    // 子类重写父类
    // 方法名称相同  参数列表相同 修饰符范围可扩大  异常范围被缩小

    // 非静态方法与后面有关
    private  void method2(){
        A a = new A(); // 打印A
        a.test1();

        B b = new B(); // 打印B
        b.test1();
    }
    // 静态方法 至于左侧有关
    private static  void method3(){
        A a1 = new B(); // 打印A
        a1.test();
        B b1 = new B(); // 打印B
        b1.test();
    }
}

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
39
40
41
42
43
44
45
46

3.多态

两种定义：
a.同一方法可以根据发送对象的不同而采用多种不同的行为方式
b.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型

注意：创建实例时，应为父类的引用指向子类，即左边 引用类型比右边 实际类型大

存在条件 :继承关系 子类重写父类方法 父类引用指向子类对象 只有方法多态

以第二种定义为例：

package com.oop.demo04;

public class A {
    public void eat(){
        System.out.println("父亲吃");
    }
}

1
2
3
4
5
6
7
8

package com.oop.demo04;

public class B extends  A {
    public void eat(){
        System.out.println("儿子吃");
    }
}

1
2
3
4
5
6
7
8

package com.oop.demo04;
// 多态
// 同一方法可以根据发送对象的不同而采用多种不同的行为方式
// 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型

// 存在条件  继承关系  子类重写父类方法  父类引用指向子类对象 只有方法多态

public class Application {
    public static void main(String[] args) {
        // 多态开始 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
        B b = new B();
        A a = new B();
        Object o = new B();

        a.eat(); // 儿子吃
        b.eat(); // 儿子吃
//        o.eat(); 无方法
    }
}

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

总目录，请点击此处，Java学习