【笔记】阿里云大学Java面向对象开发课程笔记01-77课时

课时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定期回收) GarbageCollection

 

课时6 private实现封装处理

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

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

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

方法一般不使用private

语法格式：

       private 属性;

 

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

publicclass Person {

       private String name;

      

       public void setName(String a) {

              name = a;

       }

       public void getName() {

              return name;

       }

}

 

publicstatic void main (String[] args) {

       Person per = new Person();

       per.setName("test");

       per.getName();'

}

 

规范：

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

 

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

实例化对象方式：

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

 

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

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

new：开辟新的堆内存空间

类名称()：构造方法

 

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

new的时候才调用构造方法

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

 

publicclass Person {

       private String name;

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

       }

       public void setName(String a) {

              name = a;

       }

       public void getName() {

              return name;

       }

}

 

publicstatic void main (String[] args) {

       Person per = new Person();

       per.setName("test");

       per.getName();'

}

 

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

publicvoid Person()

publicPerson()

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

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

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

定义类的步骤：

1. 写属性

2. 写构造方法

3. 写普通方法

 

匿名对象：

只有这样定义： newPerson();

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

 

课时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};

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

 

缺陷：长度固定

 

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

行列集合

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

语法模式和一维一样

intdata[][] = 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 数组的定义与使用（数组与方法的操作）

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

publicstatic void printArray(int temp[]) {

       //

}

 

方法返回数组

publicstatic int[] init() {

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

}

 

传入数组，返回数组

publicstatic 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. 基础排序操作：

冒泡排序：

publicclass 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 数组的定义与使用（数组转置）

首尾交换

1. 新定义一个空数组，然后把原数组的值从后到前存入新的数组

问题：开辟了两块相同的堆内存空间，造成浪费

2. 在原数组上反转

计算数组长度/2，交换次数为n，n =(array.length -1)/2

0 和length-1交换

1 和length-2交换

2 和length-3交换

n 和length-n-1交换

 

课时18 数组的定义与使用（二分查找法）

指定的数组中查找某个元素的位置

前提：数组先排序

mid =head/2 + tail/2

原理

比如一个排序好的数组

0,1,2,3,4,5,6,7,8

 

查找7

第一次查找

from:0

to:8

mid:4

索引为4的数比7小，所以赋值（第二次查找）

from:4+1

to:8

mid:(5+8)/2= 6

索引为6的数比7小，所以赋值（第三次查找）

from:6+1

to:8

mid:(7+8)/2= 7

索引为7的数为7，返回索引7

 

查找2

第一次查找

from:0

to:8

mid:4

索引为4的数比2大，所以赋值（第二次查找）

from:0

to:4-1

mid:(0+3)/2= 1

索引为1的数比2小，所以赋值（第三次查找）

from:1+1

to:3

mid:(2+3)/2= 2

索引为2的数为2，返回索引2

 

递归的结束条件是当from>= to

 

课时19 数组的定义与使用（对象数组）

核心掌握

引用数据类型为主，类或者接口

对象数组动态初始化： 类名称[] 对象数组名 =new 类名称[长度]

对象数组的静态初始化：类名称[] 对象数组名 =new 类名称[] {对象名,...}

classPerson {

       private String name;

       private int age;

       public Person(String setName,int setAge){

              name = setName;

              age = setAge;

       }

       public String getInfo() {

              return "name is " + name+ " age is " + age;

       }

}

 

publicclass ArrayDemo {

       public static void main(String[] args) {

              Person[] per = new Person[3]; //动态初始化，默认值为null

              per[0] = newPerson("A",1);

              per[1] = newPerson("B",2);

              per[2] = newPerson("C",3);

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

                     System.out.println(per[x].getInfo());

              }

              Person[] per2 = new Person[] { newPerson("D",4) }; //静态初始化

              System.out.println(per2[0].getInfo());

       }

}

 

对象保存的是堆内存的地址

 

普通数据数组堆内存直接保存数据，比如newint[]

而对象数组堆内存表示各个对象的真是数据地址（里面没有数据），如上图

 

课时20 String类的基本特点（String类两种实例化方式）

所有开发过程中都存在String类

 

第一种

String str ="hello";

str是一个对象，hello是保存在堆内存中

 

第二种

Stringstr = new String("hello");

传入"hello"的名为String的构造函数

 

课时21 String类的基本特点（字符串比较）

 

== 和 equals的区别

 

==比较的是堆内存的地址，是数值比较

equals()比较的是字符串内容，区分大小小

 

String str1 ="hello"; //把一个匿名对象值为"hello"的对象命名为str1

String str2 = newString("hello");

 

str1 == str2 结果为false

str1.equals(str2) 结果为true

 

开发过程中必须使用equals()

 

课时22 String类的基本特点（字符串常量为匿名对象）

 

String str1 ="hello"; //把一个匿名对象值为"hello"的对象命名为str1

 

开发过程中，如果要判断用户输入的字符串是否等同于指定的字符串，一定要把字符串写在前面，考虑用户没有输入数据的问题

 

操作方法1：字符串写在前面，不会报空指向异常

 

课时23 String类的基本特点（String两种实例化区别）

 

第一种 直接赋值（开发推荐做法，节省内存）

String str ="hello";

str是一个对象，hello是保存在堆内存中

多次赋值（指向的是同一个堆内存），使用了共享设计模式

JVM维护对象池， 直接赋值的时候，第一次会保存到对象池，后续如果有一样的对象，就引用一样的对象

也就是一个对象数组，可以减少同样字符串的内存开销

 

 

 

第二种，构造方法（标准做法）

（从右往左执行）

 

Stringstr = new String("hello");

传入"hello"的名为String的构造函数

会开辟2个堆内存空间，其中一个成为垃圾空间

而且这个对象没有自动保存到对象池

 

实现入池的操作

publicString intern();

 

 

课时24 String类的基本特点（字符串常量不可变更）

 

字符串对象变更：

 

 

字符串内容本身是不会变化的，变化的是字符串对象的引用

 

开发原则：

字符串采用直接赋值模式完成

比较实用equals()方法实现

字符串不要频繁改变

 

课时25 String类的常用方法（DOC文档组成）

 

 

文档组成：

1. 类的相关定义，类的名字，父类，接口等

2. 类的简介

3. 成员(field)摘要，属性就是一种成员，

4. 构造（constructor）方法说明，Deprecated建议不用

5. 方法(methods)摘要，返回值，参数说明

 

 

课时26 String类的常用方法（字符串与字符数组）

 

字符数组 变成 字符串

 

public String(char[] value)//构造方法

public String(char[] value,int offset, int count) // offset开始,count个数，构造方法

public char charAt(int index)//返回字符串索引位置的字符，索引从0开始 开发中出现的几率很低，普通方法

 

 

字符串 变成 字符数组

publicchar[] toCharArray() //普通方法

 

重点：字符串和字符数组的互相转换

publicclass StringDemo {

       public static void main(String[] args) {

              String str = "helloworld";

              System.out.println("index 2" + str.charAt(2));

              char[] data = str.toCharArray();

              for (char x : data) {

                     x -= 32; //转换成大写

                     System.out.print(x +"/");

              }

              System.out.println(newString(data));

              System.out.println(newString(data,6,5));

       }

}

 

课时27 String类的常用方法（字节与字符串）

字节：数据传输或者编码转换

 

支持：

构造方法：

public String(byte[] byte)

public String(byte[] byte,int offset, int length)

 

普通方法：

public byte[] getBytes()

public byte[] getBytes(StringcharsetName) throws UnsupportedEncodingException //编码转换

 

public class StringDemo {

      public static void main(String[] args) {

             String str = "hello world";

             byte data[] = str.getBytes();

             for (byte x : data) {

                    System.out.print(x + ",");

             }

      }

}

 

字节 -128 到 127 无法表示中文

字符才用于表示中文

 

课时28 String类的常用方法（字符串比较）

equals()方法

区分大小写

public boolean equals(StringanotherString)

不区分

public booleanequalsIgnoreCase(String anotherString)

 

 

public int compareTo(StringanotherString) //比较两个字符串的大小关系

相等返回0

如果不相等：

小于（每个字符进行对比，根据编码数字差返回第一个不相等的字符差）

大于（每个字符进行对比，根据编码数字差返回第一个不相等的字符差）

这个方法很重要

 

public class StringDemo {

      public static void main(String[] args) {

             Strin