javaday05
目录
Day05---数组+变量+OOP11
1 数组工具类Arrays1
1.1 Arrays.sort(数组)1
1.2 Arrays.toString(数组)1
1.3 Arrays.copyOf(原数组，新的长度)1
1.4 测试. 1
2 变量. 1
2.1 概念. 1
2.2 局部变量. 1
2.3 成员变量. 1
2.4 测试. 1
3 面向对象. 1
3.1 概念. 1
3.2 三大特征. 1
4 类和对象. 1
4.1 类. 1
4.2 对象. 1
4.3 类和对象的关系. 1
5 类和对象的创建和使用. 1
5.1 练习1：类的创建使用. 1
5.2 对象在内存中的存储. 1
5.3 单一对象内存图. 1
5.4 练习2：创建多个对象. 1
5.5 多个对象内存图. 1
6 封装. 1
6.1 概述. 1
6.2 private关键字. 1
6.3 练习1:封装学生. 1
7 拓展. 1
7.1 foreach循环结构. 1
7.2 [作业]创建Teacher类，并创建Teacher对象测试. 1
7.3 了解数组的扩容与缩容方式. 1
7.4 了解其他算法. 1
Day05---数组+变量+OOP1
1 数组工具类Arrays
1.1 Arrays.sort(数组)
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。
1.2 Arrays.toString(数组)
把数组里的数据，用逗号连接成一个字符串。【值1，值2】
1.3 Arrays.copyOf(原数组，新的长度)
把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置
新数组长度小于原数组，相当于截取前一部分数据
1.4 测试
创建day05工程
创建cn.tedu.arrays包
创建Test1_Arrays.java
package cn.tedu.arrays;
import java.util.Arrays;
import java.util.Random;
//测试数组的工具类
public class Test1_Arrays {
public static void main(String[] args) {
int[] array = method();//随机值数组
// [83, 59, 83, 26, 57]
System.out.println(Arrays.toString(array));
//sort()--对无需数组排序--默认是从小到大排序
//sort()底层的代码实现使用的排序算法是 优化之后的 快速排序算法
Arrays.sort(array);
//打印数组中的元素[26, 57, 59, 83, 83]
System.out.println(Arrays.toString(array));
//TODO 为什么sort()没有返回值 ，为什么copyOf()有返回值
//copyOf(m,n)--m是原数组的名称，n是新数组的长度
//数组的扩容 -- 新数组的长度 > 原数组的长度
int[] newA = Arrays.copyOf(array, 10);//完成数组的复制
// [26, 57, 59, 83, 83, 0, 0, 0, 0, 0] -- 数组的扩容
System.out.println(Arrays.toString(newA));
//数组的缩容 -- 新数组的长度 < 原数组的长度
int[] newB = Arrays.copyOf(array, 3);//完成数组的复制
// [26, 57, 59] -- 数组的缩容
System.out.println(Arrays.toString(newB));
}
//随机值数组
public static int[] method(){
//1、创建数组
int[] a = new int[5];
//2、遍历数组并改值
for(int i = 0 ; i < a.length ; i++ ) {
a[i] = new Random().nextInt(100);
}
//3、把无序数组返回调用位置
return a;
}
}
2 变量
2.1 概念
可以改变的数，称为变量。
一般通过三部分来描述一个变量。
变量类型，变量名，变量值。
其中三部分都是可以改变的，根据需要来确定即可。
变量的使用原则：就近原则。
尽量控制到最小范围。
2.2 局部变量
定义在方法里
注意：必须手动初始化，来分配内存。如：int i=5; 或者 int i; i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。
2.3 成员变量
定义在类里，方法外。
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。
八大基本类型都有各自的默认值。
引用类型的默认值都是null。
|
基本类型 |
默认值 |
|
byte |
0 |
|
short |
0 |
|
int |
0 |
|
long |
0L |
|
float |
0.0f |
|
double |
0.0d |
|
char |
‘\u0000’ |
|
boolean |
false |
2.4 测试
package cn.tedu.variable;
//测试变量的使用
public class Test2_Variable {
//1、成员变量：位置是在类里方法外 + 不需要初始化，因为有默认值 + 在整个类里都可见
static int count ;
//TODO 测试成员变量的默认值
static double m;
static boolean n;
static char o;
static String p;//引用类型
static int sum = 20;
public static void main(String[] args) {
//2、局部变量：位置是在方法里 + 必须手动初始化 + 在方法里可见
int sum = 10 ;
//3、变量名相同时：变量使用遵从就近原则
System.out.println(sum);//10，就近原则
//TODO 打印成员变量的默认值
System.out.println(count);//0
System.out.println(m);//0.0
System.out.println(n);//false
System.out.println(o);//
System.out.println(p);//null
}
}
3 面向对象
3.1 概念
Thinking in java
所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者。
面向对象是基于面向过程而言的。
我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）
3.2 三大特征
1、 封装性，把相关的数据封装成一个“类”组件
2、 继承性，是子类自动共享父类属性和方法，这是类之间的一种关系
3、 多态，增强软件的灵活性和重用性
4 类和对象
4.1 类
1、 Java语言最基本单位就是类，类似于类型。
2、 类是一类事物的抽象。
3、 可以理解为模板或者设计图纸。
4.2 对象
每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
1、 对象的状态用来描述对象的基本特征。
2、 对象的行为用来描述对象的功能。
3、 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
4、 类是一类事物的抽象，对象是具体的实现。
汽车类：
实现可以有奥迪汽车对象、有宝马汽车对象。
4.3 类和对象的关系
1、 计算机语言是用来描述现实世界事物的。通过描述事物的特征和事物的行为来描述
2、 那怎么通过java语言描述呢？通过类来描述事物，把事物的属性当做成员变量，把行为当做成员方法。
分析手机事物：
类：手机类，抽取相同的特征和功能
对象：可以按照模板生产很多个手机，比如1号手机对象，包含特有的成员变量和成员方法
5 类和对象的创建和使用
通过class关键字创建类，
通过new关键创建对象
5.1 练习1：类的创建使用
创建手机类
package cn.tedu.oop;
//这个类用来描述手机事物
//类是一类事物的抽象，只是抽象的规定一类事物该有的样子，具体的实现找对象
//描述事物：事物的特征/属性 + 事物的功能/行为
public class Phone {
//事物的特征/属性 -- 成员变量
String color; //颜色
int size;//尺寸
String pinpai;//品牌
double price;//价格
//事物的功能/行为 -- 成员方法
public void call() {//打电话
System.out.println("正在打电话");
}
//发短信
public void message() {
System.out.println("正在发短信");
}
//听音乐
public void music() {
System.out.println("正在听音乐");
}
}
创建测试类
package cn.tedu.oop;
//测试手机类的使用
public class Test3_Phone {
public static void main(String[] args) {
//通过new关键字，创建手机对象具体描述类的信息
//p是引用类型的变量，引用的是地址值
Phone p = new Phone();
//设置对象属性的值
p.color="红色";
p.size=5;
p.pinpai="HUAWEI";
p.price=9999;
//调用模板规定的属性/变量
System.out.println(p.color);//null -- "红色"
System.out.println(p.size);//0 -- 5
System.out.println(p.pinpai);//null --"HUAWEI"
System.out.println(p.price);//0.0 --9999
//调用模板规定的功能
p.call();
p.message();
p.music();
}
}
5.2 对象在内存中的存储
Java把内存分成5大区域，我们重点关注。
1、 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2、 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3、 每个堆内存的元素都有地址值
4、 对象中的属性都是有默认值的
5.3 单一对象内存图
5.4 练习2：创建多个对象
改造Phone类
package cn.tedu.oop;
//这个类用来描述手机事物：
//类是一类事物的抽象，只是抽象的规定一类事物该有的样子，具体的实现找对象
//描述事物：事物的特征/属性 + 事物的功能/行为
public class Phone {
//事物的特征/属性 -- 成员变量
String color; //颜色
int size;//尺寸
String pinpai;//品牌
double price;//价格
//事物的功能/行为 -- 成员方法
public void call() {//打电话
System.out.println("正在打电话");
}
//发短信
public void message() {
System.out.println("正在发短信");
}
//听音乐
public void music() {
System.out.println("正在听音乐");
}
//toString() -- 查看属性的值
//右键-source-toString()-ok
@Override
public String toString() {
return "Phone [color=" + color + ", size=" + size + ", pinpai=" + pinpai + ", price=" + price + "]";
}
}
创建测试类
package cn.tedu.oop;
//测试手机类的使用
public class Test3_Phone {
public static void main(String[] args) {
//通过new关键字，创建手机对象具体描述类的信息
//p是引用类型的变量，引用的是地址值
Phone p = new Phone();
//设置对象属性的值
p.color="红色";
p.size=5;
p.pinpai="HUAWEI";
p.price=9999;
//调用模板规定的属性/变量
// System.out.println(p.color);//null -- "红色"
// System.out.println(p.size);//0 -- 5
// System.out.println(p.pinpai);//null --"HUAWEI"
// System.out.println(p.price);//0.0 --9999
//由于Phone类中提供了toString()，所以直接打印p就能看属性的值
// Phone [color=红色, size=5, pinpai=HUAWEI, price=9999.0]
System.out.println(p);
//调用模板规定的功能
p.call();
p.message();
p.music();
Phone p2 = new Phone();
//设置对象属性的值
p2.color="玫瑰金";
p2.size=6;
p2.pinpai="VIVO";
p2.price=5888;
//调用模板规定的属性/变量
// System.out.println(p2.color);//null -- "红色"
// System.out.println(p2.size);//0 -- 5
// System.out.println(p2.pinpai);//null --"HUAWEI"
// System.out.println(p2.price);//0.0 --9999
//由于Phone类中提供了toString()，所以直接打印p2就能看属性的值
// Phone [color=玫瑰金, size=6, pinpai=VIVO, price=5888.0]
System.out.println(p2);
//调用模板规定的功能
p2.call();
p2.message();
p2.music();
}
}
5.5 多个对象内存图
6 封装
6.1 概述
封装是指隐藏对象的属性和实现细节
仅仅对外提供公共的访问方式。
好处：
1、 提高安全性
2、 提高重用性
6.2 private关键字
是一个权限修饰符，用于修饰成员变量和成员函数。
被私有化的成员只能在本类中访问。
6.3 练习1:封装学生
创建学生类，创建学生对象测试
创建学生类
package cn.tedu.oop;
//创建学生类--描述学生事物 属性+行为
public class Student {
// 属性 -- 成员变量
private String name;//被私有化的资源无法访问
//提供公共的访问方式 --setXxx()进行设置值
public void setName(String n) {
name = n;//给成员变量name赋值
}
//提供公共的访问方式 --getXxx()进行获取值
public String getName(){
return name;//把name属性的值，返回调用位置
}
//TODO 封装以下属性，并提供公共的set()/get()
int sno;//学号
String subject;//学科
double score;//成绩
int age;
String addr;
// 行为 -- 成员方法
//通过private关键字，实现封装，私有化资源
private void study() {
System.out.println("正在学习");
}
public void eat() {
System.out.println("正在吃饭");
}
}
创建测试类
package cn.tedu.oop;
//测试学生类的使用
public class Test4_Student {
public static void main(String[] args) {
//TODO 创建学生对象测试
Student s = new Student();
//设置属性值
// s.name="蔡徐坤";//被私有化的资源无法访问
s.setName("蔡徐坤");//私有化后可以访问公共的set()设置值
s.age=20;
s.subject="java";
s.sno=1;
s.score=20;
s.addr="北京";
//打印属性值
// System.out.println(s.name);//被私有化的资源无法访问
//私有化后可以访问公共的get()获取值
System.out.println(s.getName()+"=========");
System.out.println(s.age);
System.out.println(s.subject);
System.out.println(s.sno);
System.out.println(s.score);
System.out.println(s.addr);
//调用功能
s.eat();
// s.study();//被私有化的资源，本类之外的类都无法访问
}
}
7 拓展
7.1 foreach循环结构
//高效for循环 / foreach的循环结构
//for(1 2 : 3){}//3是要遍历的数组名称 1是数组中数据的类型 2是遍历到数据的变量名
for (int o : a) {
//打印数组中的每个元素
System.out.println(o);
}
7.2 [作业]创建Teacher类，并创建Teacher对象测试
老师事物：设置特性和功能
特征：姓名、年龄、住址
功能：讲课
测试：
1、创建Teacher对象
2、调用老师的属性和功能
3、修改老师的属性测试
4、封装Teacher类并测试
7.3 了解数组的扩容与缩容方式
7.4 了解其他算法
如：合并算法，二分算法，快速算法等，冒泡最常见，也是面试中出现率最高的
