[阿里云大学][Java面向对象开发][课程笔记][01-16课时]

笔记

课时1 面向对象简介

20180101

面向对象，模块化设计，具备可通用性，可重用

1. 封装性：内部的操作对外部不可见

2. 继承性：继续发展，可以重用设计

3. 多态性：利用这个特性得到良好的设计，可控范围内的状态改变

OOA面向对象分析

OOD面向对象设计

OOP面向对象编程

核心所在--考虑内存分配问题

面向过程，函数式过程，解决问题

20180102

课时2 类和对象（基本定义）

类：引用数据类型，内存分配问题

描述的群体共性特征（比如：人）

对象是一个具体的可以使用概念（比如具体的某个人）

类 ---> 对象

类的组成：方法（操作的行为），属性（变量，描述对象的基本特点）

课时3 类和对象（定义）

class ThisIsAClass {

       属性1;

       属性2;

       方法1() {

               方法内容

       }

       方法2() {

               方法内容

       }

}

属性可以无限定义，注意每一个方法中的代码不要太长，否则就要考虑重构；

声明并实例化对象

类名称 对象名称 = new 类名称();

分部进行

1. 声明：类名称 对象名称 = null;

2. 实例化： 对象名称 = new 类名称();

引用数据类型，new用于开辟新的堆内存；

性能调优：内存问题

对象只有实例化之后才能使用：

调用类中的属性 对象名称.属性;

调用类中的方法 对象名称.方法名();

课时4 类和对象(对象内存分析)

引用类型

堆内存：保存真正的数据，对象的属性信息

栈内存：保存的堆内存的地址，也就是堆内存的操作权

如果在定义类的时候没有给属性声明默认值，那么属性会采用类型的默认值，比如int是0，String是null

1个栈只能存储1个地址

声明并实例化对象方式：

分步方式：

如果只是声明对象，而不实例化，编译的时候不会报错，运行的时候会报错：NullPointerException

数组，类，接口会出现此类报错

课时5 类和对象（引用传递初次分析）

引用的本质是别名，别名存在栈内存中，1个堆内存可以被多个栈内存所指向（比如同一个人有多个外号，但是其实是指向同一个人）

内存分析（地址一样）

垃圾内存：（没有栈内存指向的堆内存空间，会被GC定期回收) Garbage Collection

课时6 private实现封装处理

面向对象编程有三大特性：封装、继承、多态

对象不能直接  .  操作类的属性

封装可以使用private实现（有其他实现方式，不唯一），只允许本类访问

方法一般不使用private

语法格式：

       private 属性;

配置属性使用setter方法（可以对变量做合理判断），获取属性使用getter方法

public class Person {

       private String name;

       

       public void setName(String a) {

               name = a;

       }

       public void getName() {

               return name;

       }

}

public static void main (String[] args) {

       Person per = new Person();

       per.setName("test");

       per.getName();'

}

规范：

类中的所有属性定义都是用private封装，如果需要被外部使用，就定义setter()和getter()方法

课时7 构造方法和匿名函数

实例化对象方式：

类名称 对象名称 = new 类名称();

类名称：任何对象都有其对应的类

对象名称：对象的唯一标记

new：开辟新的堆内存空间

类名称()：构造方法

构造方法和类名称一样，无返回值，声明一个类之后就会自动生成一个无参数无返回值的默认构造函数（编译后）

new的时候才调用构造方法

类的组成，属性+普通方法+构造方法

public class Person {

       private String name;

       public Person() { //默认的构造方法格式

       }

       public void setName(String a) {

               name = a;

       }

       public void getName() {

               return name;

       }

}

public static void main (String[] args) {

       Person per = new Person();

       per.setName("test");

       per.getName();'

}

构造方法不能带void修饰符，带有void的命令不标准，

public void Person()

public Person()

对于内中可以自动生成默认构造方法，前提是类中没有定义同名的构造方法

构造方法可以把类中的属性初始化（传入参数的构造方法）

构造方法可以重载（不同参数类型，不同参数个数），注意定义结构，按照参数个数采用升序或者降序排列

定义类的步骤：

1. 写属性

2. 写构造方法

3. 写普通方法

匿名对象：

只有这样定义： new Person();

没有栈空间，使用一次之后就成为垃圾内存

课时8 【第01个代码模型】综合案例：简单Java类

简单java类的开发要求

1. 类的名称有意义，可以明确的描述某一类事物

2. 类中所有的属性使用private封装，并提供setter()/getter()方法

3. 类中必须保留一个无参数的构造方法

4. 类中的所有方法不允许使用System.out方法，输出要在调用处完成

5. 类中应该提供一个返回类完整信息的方法，getInfo()

开发中最多是简单java类

开发原则

课时9 数组的定义和使用（基本概念）

一组相关类型的变量集合，可以按照统一的方式进行操作，是引用类型

数组动态初始化（声明之后，每个数据都为默认值，比如int为0）

1. 声明并开辟空间

数据类型[] 数组名称 = new 数据类型[长度]

或者

数据类型 数组名称[] = new 数据类型[长度]

2. 分部进行（先声明，再实例化）

数据类型[] 数组名称 = null

数组名称 = new 数据类型[长度]

操作方式：

数组的访问通过索引完成，索引从0开始，到数组长度-1

比如int[] data = new int[3]，索引为0,1,2

- 数组初始化之后，每个数据都为默认值，比如int为0

- 是一个有序的集合操作，采用循环模式操作

- 数组长度 data.length

课时10 数组的定义与使用（数组引用传递）

int[] data = new int[3];

int[] temp = null;

temp = data;

//temp 和 data指向同一块堆内存

//data的栈内存存的是地址

课时11 数组的定义与使用（数组静态初始化）

数组定义的时候设定内容

语法：

1. 简化格式

数据类型数组名称[] = {value,value,...,value};

2. 建议使用，完整格式，可以使用匿名数组

数据类型 数组名称[] =new 数据类型[] {value,value,...,value};

int data[] = new int[] {1,2,3,4,5,6};

缺陷：长度固定

课时12 数组的定义与使用（二维数组）

行列集合

数组[行索引][列索引]

语法模式和一维一样

int data[][] = new int[][] { {1,2,3},{4,5},{6,7,8,9} };

遍历数组使用2重循环，外部行，内部列

for (int x=0; x < data.length; x++) {

       for (int y=0; y < data[x].length; y++) {

               System.out.print(data[x][y]);

       }

}

//开发过程中出现二维数组的概率不高

课时13 数组的定义与使用（数组与方法的操作）

方法接收数组（参数为数组）

public static void printArray(int temp[]) {

       //

}

方法返回数组

public static int[] init() {

       return new int[] {1,2,3,4,5};

}

传入数组，返回数组

public static void inc(int arr[]) {

       for (int x = 0; x < arr.length; x++) {

               arr[x] *= 2;

       }

}

课时14 数组的定义与使用（Java对数组的支持）

1. 数组排序(基本数据类型数组)，升序

java.util.Arrays.sort(数组名称);

2. 数组拷贝（一个数组的部分内容替换另外一个数组的部分内容），连续替换

System.arraycopy(原数组名称，原数组起点，目标数组名称，目标数组起点);

//逻辑训练，开发用不上

课时15 数组的定义与使用（数组案例：数组数据统计）

数组的线性操作

最大，最小，平均，总和

循环操作模式完成

方法优化

课时16 数组的定义与使用（数组案例：数组排序）

1. 基础排序操作：

冒泡排序：

public class ArrayDemo {

    public static void main(String[] args){

        int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

        for (int i = 0; i < score.length -1; i++){    //最多做n-1趟排序

            for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)

                if(score[j] < score[j + 1]){    //把小的值交换到后面

                    int temp = score[j];

                    score[j] = score[j + 1];

                    score[j + 1] = temp;

                }

            }            

            System.out.print("第" + (i + 1) + "次排序结果：");

            for(int a = 0; a < score.length; a++){

                System.out.print(score[a] + "\t");

            }

            System.out.println("");

        }

            System.out.print("最终排序结果：");

            for(int a = 0; a < score.length; a++){

                System.out.print(score[a] + "\t");

       }

    }

}

课时17 数组的定义与使用

课时18 数组的定义与使用

课时19 数组的定义与使用