Retrospection

Java中方法的定义: 

1
2
3
4
修饰符 (public static) 返回值的数据类型 (void/int/boolean...) 方法名(数据类型 参数名1, 数据类型 参数名2) {
		方法体;
		return 具体的返回值;(如果返回值是void类型可以不写)
}

其中修饰符,可以简单的理解为: public static(后续会说的)

具体案例: 

1
2
3
4
public static int getSum(int a, int b){
        int sum = a + b;
        return sum;
}

方法重载OverLoaded

简单理解方法重载: 就是在同一个类中, 出现方法名称相同, 但是参数列表不同(参数个数, 参数的数据类型不同)两个或两个或者多个方法

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
/*
方法重载: 在同一个类中, 出现方法名称相同, 但是参数列表不同的(个数不同,对应的数据类型不同)的两个或多个方法
    方法重载与返回值的数据类型无关
应用场景: 用来解决功能相似或相同, 但是方法名不能重名的问题
*/
public class OverLoaded {
//boolean flag = compare(10, 20)
public static void main(String[] args) {
    boolean flag = compare(10, 20);
    System.out.println(flag);
    short s1 = 11, s2 = 22;
    compare(s1, s2);

}

    public static boolean compare(byte b1, byte b2) {
        System.out.println("比较byte类型");
        return b1 == b2;
    }
    public static void compare(short b1, short b2){
        System.out.println("比较short类型");
        System.out.println(b1 == b2);
    }
    public static boolean compare(int b1, int b2){
        System.out.println("比较int类型");
        return b1 == b2;
    }
    public static boolean compare(long b1, long b2){
        System.out.println("比较long类型");
        return b1 == b2;
    }
}

Java中参数传递问题

形参如果是基本类型, 则形参的改变对实参没有任何影响*,因为传递的是:* *数值,*也叫值传递
形参如果是引用类型, 则形参的改变对实参有直接影响, 因为传递的是: 地址值, 也叫引用传递

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
/*
演示: java中参数传递的问题
    1形参如果是基本类型, 则形参的改变对实参没有任何影响,因为传递的是: 数值,也叫值传递
    2形参如果是引用类型, 则形参的改变对实参有直接影响, 因为传递的是: 地址值, 也叫引用传递
    3String虽然是引用类型
*/
public class TransParameter {
    //定义主函数
    public static void main(String[] args) {
        int number = 10;
        System.out.println("调用change方法前: " + number);
        change(number);  //实参
        System.out.println("调用change方法后: " + number);
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前: " + arr[1]);
        change(arr);  //调用change方法
        System.out.println("调用change方法后: " + arr[1]);
    }
    public static void change(int number){  //形参
        number = 100;
    }
    //方法重载
    public static void change(int[] arr){
        arr[1] = 200;
    }
}

面向对象ObjectOriented

面向对象是什么: 它是一种编程思想, 强调的是以 对象 为基础完成各种操作.

面向对象的三大基本特性, 封装,继承,多态.

类: 属性和行为的集合, 是一个抽象的概念, 看不见, 也摸不着.
对象: 类的具体体现, 实现.
属性: 也叫成员变量, 字段, 就是事物的外在特征(名词).
行为: 也叫成员方法, 就是描述事物能够做什么(动词).

如何定义类

1
2
3
4
5
6
public class 类名 {
    //属性, 名词, 全部私有
    //构造方法, 空参, 全参.
    //getXxx(), setXxx()
    //行为, 动词
}

封装

概述:
封装就是隐藏对象的属性和实现细节, 仅对外提供一个公共的访问方式.
Q1: 怎么隐藏?
A1: 可以通过 private 关键字实现, 被它修饰的内容只能在本类中直接访问.
Q2: 公共的访问方式是什么? A2: 指的是 getXxx() 和 setXxx()方法.
Q3: 封装的好处是什么? A3: 提高代码的安全性(private保证), 提高代码的复用性(方法).
Q4: 封装的弊端是什么, 针对于private来讲? A4: 代码的冗余度增加了.
Q5: 目前我们在setPrice()方法中是没有做到见名知意的, 只是传入了一个p, 那如何解决这个问题呢? A5: 通过 this 关键字解决, 它是用来解决局部变量和成员变量重名问题的. this关键字解释: 它表示当前对象的引用, 谁调用, 它就代表谁.

Demo

Student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.heima.oop;

public class Student {
    // 定义成员变量
    int age = 30;
    // 成员方法
    public void show(){
        // 局部变量
        int age = 20;
        // 打印类中成员变量的值
        System.out.println(age);
        // 打印对象的属性
        System.out.println(this.age);
    }
}

Student_demo.java

1
2
3
4
5
6
7
8
9
10
11
12
package com.heima.oop;

public class StudentDemo {
    public static void main(String[] args) {
        // 首先创建对象
        Student s = new Student();
        // 调用student类中的show方法
        s.show();
        // 打印类中属性
        System.out.println(s.age);
    }
}

result结果: 为20, 30, 30

为什么:

Java中使用变量遵循就近原则, 局部有就使用, 没有就去本类的成员位置找,有就使用, 没有就去父类的成员位置找, 有就使用, 没有就报错.

这里不考虑父类的父类这种情况,因为会一直找下去, 直至找到Object类.

私有属性Private

Demo

Student.java

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.heima.private_exercise;
// 学生类
public class Student {
    // 属性,全部私有
    private String name;
    private int age;
    public Student(){
        System.out.println("我是空参构造");
    }
    public Student(String name, int age){
        System.out.println("我是全参构造");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
    // 行为
    public void study(){
        System.out.println("好好学习,天天向上");
    }
}

PrivateDemo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.heima.private_exercise;

public class PrivateDemo {
    public static void main(String[] args) {
        // 使用空参构造
        Student s = new Student();
        // 给属性赋值,并重新打印
        s.setName("刘亦菲");
        s.setAge(33);
        System.out.println(s.getName() + ',' + s.getAge());
        // 调用类中的成员方法
        s.study();
        // 使用全参构造
        Student s2 = new Student("高圆圆",33);  // 使用字符串必须用""双引号
        System.out.println(s2.getName() + "," + s2.getAge());
        s2.study();
    }
}

继承

概述

实际开发中, 我们发现好多类中的部分内容是相似的或者相同的, 每次写很麻烦, 针对于这种情况, 我们可以把这些相同(相似)的然后单独的定义到一个类中, 然后让那多个类和这个类产生关系, 这个关系就叫继承, Java中, 继承用 extends 关键字表示.

格式

class A extends B { //子承父业 }

叫法

类A: 子类, 派生类
类B: 父类, 基类, 超类.

好处

1. 提高代码的复用性.
  1. 提高代码的可维护性.
  2. 让类与类之间产生关系, 是多态的前提.

弊端

类与类之间的耦合性太强了.
开发原则: 高内聚, 低耦合.

继承关系中成员的特点:

成员变量: 就近原则. 构造方法: 子空参访问父空参, 子全参访问父全参. 成员方法: 就近原则.

Demo

Animal.java

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
package com.heima.extend;
// 动物类
public class Animal {
    //属性, 全部私有
    private String name;
    private int age;
    // 成员变量
    int num = 30;
    // 构造,空参,全参(alt + insert
    public Animal() {
    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //行为
    public void eat(){
        System.out.println("动物会吃!");
    }
}

Cat.java

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
package com.heima.extend;
// 猫类
public class Cat extends Animal {
    public Cat(){
        super();
    }
    public Cat(String name , int age){
        // super() : 子类所有构造方法的第一行默认都有一个super() 访问父类的空参
        // this.name = name;  这里会报错,因为没有name这个私有属性
        super(name, age);
        // 子全参访问父全参, 子空参访问父空参
    }
    // 成员变量
    int num = 20;
    public void show(){
        // 局部变量
        int num = 10;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
    public void eat(){
        System.out.println("猫吃鱼!");
    }
}

Demo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.heima.extend;

public class Demo1 {
    public static void main(String[] args) {
        // 创建对象
        Cat c = new Cat();
        // 给属性赋值,并重新打印
        c.setName("加菲猫");
        c.setAge(13);
        System.out.println(c.getName() + "," + c.getAge());
        // 调用类中的成员方法(就近原则,如果Cat类中没有重写Animal中的eat方法,则会调用Animal中的eat方法
        c.eat();
        //演示方法重写
        NewPhone np = new NewPhone();
        np.call();

    }
}

多态

1
2
Animal an = new Cat();  //猫是动物, 这个是多态.
Cat c = new Cat();      //猫是猫, 这个不是多态.

多态的好处:
父类型可以作为方法的形参类型, 这样可以接受其任意的子类对象.
根据多态的成员方法调用规则”编译看左, 运行看右”传入什么对象, 就掉谁的方法

前提:

  1. 必须有继承或者实现关系.
  2. 必须父类(父接口)引用指向子类对象.
  3. 必须有方法重写, 不然多态无意义.

多态中的成员方法特点:

成员变量: 编译看左, 运行看左. 成员方法: 编译看左, 运行看右.

多态的好处:

父类型可以作为方法的形参类型, 这样可以接受其任意的子类对象.
根据多态的成员方法调用规则”编译看左, 运行看右”传入什么对象, 就掉谁的方法.

多态的弊端:

父类引用不能直接使用子类的特有成员.

如何解决?
向下转型.

1
2
Animal an = new Cat();     向上转型.    double d = 10;  隐转
Cat c = (Cat)an;           向下转型.    int a = (int)d; 强转