0510课堂笔记--数组-面向对象

1. 数组的工具类

Arrays.toString（）–查看数组元素

Arrays.sort（）–数组元素排序

Arrays.copyOf（）–复制数组/数组的扩容 /缩容

Arrays.copyOfRange（）–指定首位元素复制原数组

package cn.tedu.arrays;

import java.util.Arrays;

//本类测试数组的 工具类Arrays
public class TestArraysSortAPI {
	public static void main(String[] args) {
		// f1();//测试toString--查看数组元素
		// f2();//测试 sort--数组元素排序
		f3();// 测试 copyof--复制数组 /数组的扩容/缩容
	}

	public static void f3() {
		// 3. 创建测试数组
		/** 数组一旦创建，长度不可改变 */
		int[] from = { 1, 2, 3, 4, 5 };
		// 3.1 数组的普通复制
		/** 两个参数：(original, newLength) 要复制谁，复制的长度 */
		int[] to = Arrays.copyOf(from, 5);
		System.out.println(Arrays.toString(to));

		// 3.2 数组的扩容
		/**
		 * 扩容：扩充 容量，并不是修改远数组 先创建对应长度的新数组，复制原数组的数据，其余位置为int默认值0
		 */
		int[] to2 = Arrays.copyOf(from, 10);
		System.out.println(Arrays.toString(to2));

		// 3.3 数组的缩容
		/**
		 * 扩容：减少容量，并不是修改远数组 先创建对应长度的新数组，复制原数组前面部分数据，类似于截取
		 */
		int[] to3 = Arrays.copyOf(from, 3);
		System.out.println(Arrays.toString(to3));

		// 3.4 指定首尾元素复制原数组
		// (original, from, to)复制的是下标[2,4)位置上的元素a(2)--a(3)
		int[] to4 = Arrays.copyOfRange(from, 2, 4);
		System.out.println(Arrays.toString(to4));
	}

	// 2. 创建f2（）测试Arrays.sort
	public static void f2() {
		// 2.1 准备一个乱序数组
		int[] a = { 9, 55, 2, 355, 223, 0 };
		// 2.2 用工具类方法对a数组进行排序
		/**
		 * sort()方法是底层优化过的快速排序算法 是直接对无序数组进行排序，排序后a数组就是有序数组
		 */
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
	}

	// 1. 创建f1（）用来测试Arrays.toString(数组名)
	public static void f1() {
		// 定义长度为3的String类型的数组
		String[] s = new String[3];
		s[0] = "A";
		s[1] = "B";
		s[2] = "C";
		System.out.println(s);// [Ljava.lang.String;@15db9742 这是地址值
		System.out.println(Arrays.toString(s));// [A, B, C] 具体元素
	}
}

2. 面向对象 类 对象 封装

2.1 面向对象概念

面向对象和面向方法都是编程思想

2.2 面向对象的三大特征

封装 继承 多态

2.2 类和对象

类：Java最基本的单位，类似于类型，类是一类事物的抽象，可以理解为模版或者设计图纸

对象：三个特征：状态，行为和标识

状态–基本特征–成员变量

行为–功能–方法

标识–对象内存在唯一的地址值和其他对象区分

类是一类事物的抽象，对象是具体的实现

2.3 类的创建练习

package cn.tedu.oop;

//本类用于练习面向对象
/**分析手机这一类事物--通过类来描述
 * 属性：品牌 价格 颜色 尺寸
 * 功能：打电话 发微信 看视频
 * */
/**
 * 在一个java文件中可以写多个class，但是被public修饰的只能有一个 而且这个公共类的名字必须 与文件名保持一致
 */
public class TestCreateClass {
	// 2. 创建入口函数
	public static void main(String[] args) {

		// 3. 在main（）方法中通过new关键字来创建对应类的对象
		Phone p = new Phone();

		// 4. 通过.来完成对象功能的调用
		p.call();// 调用打电话的方法
		p.message();
		p.video();

		// 5. 通过.来查看对象的属性值
		System.out.println(p.brand);
		System.out.println(p.color);
		System.out.println(p.price);
		System.out.println(p.size);

		// 6.创建第二个对象
		Phone p2 = new Phone();

		// 8.给p2对象设置属性值
		p2.color = "五彩斑斓的黑";
		p2.brand = "banana";
		p2.price = 6666.66;
		p2.size = 233;

		// 7. 通过p2对象 查看属性值
		System.out.println(p2.brand);
		System.out.println(p2.color);
		System.out.println(p2.price);
		System.out.println(p2.size);

		// 9.通过p2对象，调用模版里的功能
		p2.call();
		p2.message();
		p2.video();
	}
}

/**
 * 通过class关键字描述一个类型 类是一类事物的抽象，抽象的规定这一类事物的特征与行为
 */
//1.创建手机类
class Phone {
	// 特征（属性）--用类的成员变量来 描述--位置：类里方法外
	String brand;// 品牌
	double price;
	double size;
	String color;

	// 功能（行为）--用类的方法来描述--修饰符 返回值类型 方法名（参数列表 ）｛方法体｝
	public void call() {
		System.out.println("正在打电话");
	}

	public void message() {
		System.out.println("发微信");
	}

	public void video() {
		System.out.println("看视频");
	}
}

2.4 对象在内存中的储存

Java把内存分成5大区域，我们重点关注栈和堆。

一般来讲局部变量存在栈中，方法执行完毕内存就被释放
对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
每个堆内存的元素都有地址值
对象中的属性都是有默认值的
TIPS: 栈与队列指的是一种数据的结构。
栈：先进后出（FILO – First In Last Out）
队列：先进先出（FIFO – First In First Out）

p2.brand = “HUAWEI”;
就是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应的Phone对象,并对其对应的属性值进行修改
p2.eat();
也是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应Phone对象,执行Phone对象的eat()方法

创建对象时，内存经历了什么？

1.在栈内存中开辟一块空间，存放引用类型变量p，并把p压入栈底

2.在堆内开辟一块空间，存放Phone对象

3.完成对象的初始化，并赋予默认值

4.给初始化完毕的对象赋予唯一的地址值

5.把地址值交给引用类型变量p保存

2.5 封装

封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
好处:

1. 提高安全性

2. 提高重用性

   private关键字：是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

2.5.1 封装练习

package cn.tedu.oop;

//本类用于测试封装
public class TestPrivate {
	public static void main(String[] args) {
		// 4. 创建学生类对象--new
		Student s = new Student();
		// 5. 初步测试学生类对象s
		// s.eat();//调用s对象的方法
		s.study();
		s.sno = 441513;
		s.name = "程序猿";
		// s.subject="java培优";//The field Student.subject is not visible
		System.out.println(s.name);// 调用s对象的name属性，查看它的值
		System.out.println(s.sno);
		// System.out.println(s.subject);
		// 8. 通过student类中提供的get/set方法操作属性值subject
		s.setSubject("JAVA CGB");// 调用对外公共赋值方式，用set.
		System.out.println(s.getSubject());// 调用对外提供的公共查看方式,用get.
	}
}

//1.通过关键字class创建 学生类--用来描述学生这一类型--属性+行为 
/**
 * 封装：通过private关键字（权限修饰符 ）来修饰成员变量/成员方法 被修饰的成员实现了私有化，访问权限只能在本类中访问
 */
class Student {
	public char[] setSubject;
	// 2. 定义属性--成员变量
	String name;// 姓名
	int sno;// 学号
	/* private对subject进行了私有化，只能在本class里面使用，外面的main方法就无法访问了 */
	private String subject;// 科目

	/** 6. 对外提供公共的属性值设置方式 */
	public void setSubject(String s) {
		subject = s;// 将用户设置的变量s赋值给subject
	}

	/** 7. 对外提供公共的属性值查看方式 */
	public String getSubject() {
		return subject;
	}

	// 3. 定义功能--方法
	public void study() {
		System.out.println("正在学习JAVA~");
	}

	public void eat() {
		System.out.println("干饭人");
	}
}

package cn.tedu.oop;

//本类用于oop综合练习
public class TestTeacher {
	// 4.在公共类中，创建入口函数main（）方法
	public static void main(String[] args) {
		// 5.创建Teacher对象
		Teacher t = new Teacher();
		// 6.1设置属性值：对象.set.name
		t.setName("白小纯");
		// 6.2打印获取到的属性值:对象.get.name
		System.out.println(t.getName());
	}
}

//1.创建类
class Teacher {
	// 2.1提供属性
	// 2.2对属性进行封装：private
	private String name;
	private String gender;// 性别
	private int age;
	private double salary;// 薪水

	// 3. 创建一些自己的功能方法
	public void ready() {
		System.out.println("正在备课~");
	}

	public void teach() {
		System.out.println("正在授课~");
	}

	// 2.3需要给外界提供公共的属性值设置和获取方法
	// 快捷键：右键->Source->GT全选
	public String getName() {
		return name;
	}

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

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public int getAge() {
		return age;
	}

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

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}
}

类–一类事物的抽象–模版

1.创建类

2.创建类的属性

3.封装类的属性

4.提供get与set方法

5.提供一些本类分功能

创建对象

通过对象的调用方法

1.可以调用set方法设置修改私有属性的值

2.可以调用get方法获取私有属性的值

3.可以调用普通的方法执行对应的功能

新单词

field 字段

visible 可见的