30天搞定Java--day8
文章目录
- 每日一考和复习
- 面向对象
-
- 面向过程与面向对象
-
- 概念
- 面向对象的思想概述
- Java语言的基本元素：类和对象
-
- 类和对象的思想概述
- Java类及类的成员
- 对象的创建和使用
-
- 内存解析
- 类的成员之一：属性(field)
-
- 变量的分类：成员变量与局部变量
- 类的成员之二：方法(method)
- 练习
每日一考和复习
每日一考
- 使用冒泡排序，实现如下的数组从小到大排序
int[] arr = new int[]{
34,5,22,-98,6,-76,0,-3};
int arrLength = arr.length;
for(int i = 0;i < arrLength - 1;i++) {
for(int j = 0;j < arrLength - 1 - i;j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
- 如何反转上面的数组。请代码实现
for(inti = 0,j = arrLength - 1;i < j;i++,j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
- 复制上述数组，得到一个新的数组
int[] arrcopy = newint[arrLength];
for(int i = 0;i < arrLength;i++) {
arrcopy[i] = arr[i];
}
- 使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息
for(int i = 0;i< arrLength;i++) {
if(arr[i] == 22) {
System.out.println(i);
return;
}
}
System.out.println("don't find 22");
- 数组中常见的异常有哪些？请举例说明
// 数组越界
int[] arr = {
1,2,3};
System.out.println(arr[4]);
// 空指针
int[] arr1;
System.out.println(arr1[1]);
复习
day7的学习内容
面向对象
Java面向对象学习的三条主线：
-
1.Java类及类的成员：属性、方法、构造器；代码块、内部类
-
2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)
-
3.其它关键字：this、super、static、final、abstract、interface、package、import等
面向过程与面向对象
概念
- 二者都是一种思想，面向对象是相对于面向过程而言的
- 面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做
- 面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
- 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等
/*
* “人把大象装进冰箱”
* 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
*
* ① 把冰箱门打开
* ② 抬起大象，塞进冰箱
* ② 把冰箱门关闭
*
* 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
* 人{
* 打开(冰箱){
* 冰箱.开开();
* }
*
* 抬起(大象){
* 大象.进入(冰箱);
* }
*
* 关闭(冰箱){
* 冰箱.闭合();
* }
*
* }
*
* 冰箱{
* 开开(){};
* 闭合(){};
* }
*
* 大象{
* 进入(冰箱){};
* }
*/
面向对象的思想概述
- 程序员从面向过程的执行者转化成了面向对象的指挥者
- 面向对象分析方法分析问题的思路和步骤：
- 根据问题需要，选择问题所针对的现实世界中的实体
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类
- 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构
- 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具
Java语言的基本元素：类和对象
类和对象的思想概述
- 类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
- ->面向对象程序设计的重点是类的设计
- ->设计类，就是设计类的成员
- “万事万物皆对象”
Java类及类的成员
- 属性：对应类中的成员变量
属性 = 成员变量 = filed = 域、字段 - 行为：对应类中的成员方法
方法 = 成员方法 = 函数 = method
对象的创建和使用
类和对象的使用（面向对象思想落地的实现）：
- 创建类，设计类的成员
- 创建类的对象
- 通过“对象.属性”或“对象.方法”调用对象的结构
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
//测试类
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//Scanner scanner = new Scanner(System.in);
//调用对象的结构：属性、方法
//调用属性：“对象.属性”
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法：“对象.方法”
p1.eat();
p1.sleep();
p1.talk("Chinese");
//*******************************
Person p2 = new Person();
System.out.println(p2.name);//null
System.out.println(p2.isMale);
//*******************************
//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
Person p3 = p1;
System.out.println(p3.name);//Tom
p3.age = 10;
System.out.println(p1.age);//10
}
}
//创建类，设计类的成员
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat(){
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language){
System.out.println("人可以说话,使用的是：" + language);
}
}
内存解析
- 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配
- 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放
- 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
Person p1 = new Person();
p1.name = "Tom";
p1.isMale = true;
Person p2 = new Person();
sysout(p2.name);//null
Person p3 = p1;
p3.age = 10;
类的成员之一：属性(field)
语法格式：
修饰符 数据类型 属性名 = 初始化值 ;
- 说明1: 修饰符
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final (暂不考虑) - 说明2：数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。 - 说明3：属性名
属于标识符，符合命名规则和规范即可
变量的分类：成员变量与局部变量
- 在方法体外，类体内声明的变量称为成员变量
- 在方法体内部声明的变量称为局部变量
- 注意：二者在初始化值方面的异同:
同：都有生命周期
异：局部变量除形参外，均需显式初始化
成员变量（属性）和局部变量的区别
| 成员变量 | 局部变量 | |
|---|---|---|
| 声明的位置 | 直接声明在类中 | 方法形参或内部、代码块内、构造器内等 |
| 修饰符 | private、public、static、final等 | 不能用权限修饰符修饰，可以用final修饰 |
| 初始化值 | 有默认初始化值 | 没有默认初始化值，必须显式赋值，方可使用 |
| 内存加载位置 | 堆空间 或 静态域内 | 栈空间 |
类的成员之二：方法(method)
什么是方法(method、函数):
- 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中
也称为函数或过程 - 将功能封装为方法的目的是，可以实现代码重用，简化代码
- Java里的方法不能独立存在，所有的方法必须定义在类里
// 举例
public class Person{
private int age;
public int getAge() {
//声明方法getAge()
return age;
}
public void setAge(int i) {
//声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
方法的声明格式
修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, …)｛
方法体程序代码;
return 返回值;
｝
其中：
修饰符：public,缺省,private, protected等
返回值类型：
没有返回值：void
有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据
方法的分类：按照是否有形参及返回值
方法的调用
方法通过方法名被调用，且只有被调用才会执行。
练习
- 创建一个Person类，其定义如下：
要求：
(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
public class Person {
String name;
int age;
/**
* sex:1 表明是男性
* sex:0 表明是女性
*/
int sex;
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println("age:" + age);
}
public int addAge(int i){
age += i;
return age;
}
}
// 调用
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "Tom";
p1.age = 18;
p1.sex = 1;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为：" + newAge);
System.out.println(p1.age);//20
//*************************
Person p2 = new Person();
p2.showAge();//0
p2.addAge(10);
p2.showAge();//10
p1.showAge();
}
}
- 利用面向对象的编程方法，设计类Circle计算圆的面积
//测试类
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.radius = 2.1;
//对应方式一：
double area = c1.findArea();
System.out.println(area);
//对应方式二：
c1.findArea();
//错误的调用
double area = c1.findArea(3.4);
System.out.println(area);
}
}
//圆
class Circle{
//属性
double radius;
//求圆的面积
//方式一：
public double findArea(){
double area = Math.PI * radius * radius;
return area;
}
//方式二：
public void findArea(){
double area = Math.PI * radius * radius;
System.out.println("面积为：" + area);
}
//错误情况：半径作为属性更好
public double findArea(double r){
double area = 3.14 * r * r;
return area;
}
}
- 矩形
/*
* 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。
* 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
* 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
*
* 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
* 并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
*/
public class Exer3Test {
public static void main(String[] args) {
Exer3Test test = new Exer3Test();
//3.1测试
test.method();
//3.2测试
//方式一：
int area = test.method();
System.out.println("面积为：" + area);
//方式二：
System.out.println(test.method());
//3.3测试
int area = test.method(12, 10);
System.out.println("面积为：" + area);
}
//3.1
public void method(){
for(int i = 0;i < 10;i++){
for(int j = 0;j < 8;j++){
System.out.print("* ");
}
System.out.println();
}
}
//3.2
public int method(){
for(int i = 0;i < 10;i++){
for(int j = 0;j < 8;j++){
System.out.print("* ");
}
System.out.println();
}
return 10 * 8;
}
//3.3
public int method(int m,int n){
for(int i = 0;i < m;i++){
for(int j = 0;j < n;j++){
System.out.print("* ");
}
System.out.println();
}
return m * n;
}
}
- 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
package com.atguigu.exer;
public class StudentTest {
public static void main(String[] args) {
// 声明Student类型的数组
Student[] stus = new Student[20]; // String[] arr = new String[10];
for (int i = 0; i < stus.length; i++) {
// 给数组元素赋值
stus[i] = new Student();
// 给Student对象的属性赋值
stus[i].number = (i + 1);
// 年级：[1,6]
stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
// 成绩：[0,100]
stus[i].score = (int) (Math.random() * (100 - 0 + 1));
}
// 遍历学生数组
for (int i = 0; i < stus.length; i++) {
// System.out.println(stus[i].number + "," + stus[i].state
// + "," + stus[i].score);
System.out.println(stus[i].info());
}
System.out.println("********************");
// 问题一：打印出3年级(state值为3）的学生信息。
for (int i = 0; i < stus.length; i++) {
if (stus[i].state == 3) {
System.out.println(stus[i].info());
}
}
System.out.println("********************");
// 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
for (int i = 0; i < stus.length - 1; i++) {
for (int j = 0; j < stus.length - 1 - i; j++) {
if (stus[j].score > stus[j + 1].score) {
// 如果需要换序，交换的是数组的元素：Student对象！！！
Student temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
// 遍历学生数组
for (int i = 0; i < stus.length; i++) {
System.out.println(stus[i].info());
}
}
}
class Student {
int number;// 学号
int state;// 年级
int score;// 成绩
// 显示学生信息的方法
public String info() {
return "学号：" + number + ",年级：" + state + ",成绩：" + score;
}
}
package com.atguigu.exer;
/*
* 此代码是对StudentTest.java的改进：将操作数组的功能封装到方法中。
*
*/
public class StudentTest1 {
public static void main(String[] args) {
// 声明Student类型的数组
Student1[] stus = new Student1[20];
for (int i = 0; i < stus.length; i++) {
// 给数组元素赋值
stus[i] = new Student1();
// 给Student对象的属性赋值
stus[i].number = (i + 1);
// 年级：[1,6]
stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
// 成绩：[0,100]
stus[i].score = (int) (Math.random() * (100 - 0 + 1));
}
StudentTest1 test = new StudentTest1();
// 遍历学生数组
test.print(stus);
System.out.println("********************");
// 问题一：打印出3年级(state值为3）的学生信息。
test.searchState(stus, 3);
System.out.println("********************");
// 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
test.sort(stus);
// 遍历学生数组
test.print(stus);
}
public void print(Student1[] stus) {
for (int i = 0; i < stus.length; i++) {
System.out.println(stus[i].info());
}
}
public void searchState(Student1[] stus, int state) {
for (int i = 0; i < stus.length; i++) {
if (stus[i].state == state) {
System.out.println(stus[i].info());
}
}
}
public void sort(Student1[] stus) {
for (int i = 0; i < stus.length - 1; i++) {
for (int j = 0; j < stus.length - 1 - i; j++) {
if (stus[j].score > stus[j + 1].score) {
// 如果需要换序，交换的是数组的元素：Student对象！！！
Student1 temp = stus[j];
stus[j] = stus[j + 1];
stus[j + 1] = temp;
}
}
}
}
}
class Student1 {
int number;// 学号
int state;// 年级
int score;// 成绩
// 显示学生信息的方法
public String info() {
return "学号：" + number + ",年级：" + state + ",成绩：" + score;
}
}