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