Java第五课:类和对象
Java第五课:类和对象
- Java第五课:类和对象
- 1.1 上周回顾
- 1.2 作业讲解
- 1.3 类和对象:
- 1.4 面向对象:
- 1.4.1 类的概念:
- 1.4.2 类的基本结构:
- 1.4.3 对象的概念：
- 1.4.4 类和对象关系与区别
- 1.5 面向对象特征：
- 1.5.1 封装:
- 1.5.2 封装的实现:
- 1.6 类和对象的声明
- 1.6.1 类的基本格式:
- 1.6.2 类中的属性定义:
- 1.6.3 类中方法的定义:
- 1.6.4 求两个数字中的最大值:
- 1.6.5 课堂作业:
- 1.6.6 对象的创建:
- 1.6.7 属性和方法的调用:
- 1.6.8 成员变量和局部变量:
- 1.6.9 方法的重载:
- 1.6.10 构造方法
- 1.6.11 this关键字:
- 1.6.12 课堂练习:
- 1.7 总结:
- 1.8 作业：
1.1 上周回顾
- Java语言和平台;jdk的安装和环境变量的配置;java命令;java代码的执行过程
- 标识符的定义; 例如：定义一个变量的基本规范; 变量和常量的区别;
- 数据类型（简单类型(8个) 引用类型 类/接口/String/数组 /枚举等）
类型的转换; 都是基本类型： 强制转换 ,自动转换
String str = “123” 转换为int类型?
Int n = (int)“123”; ?
- 运算符(算术 比较 逻辑（短路） 赋值 位 ， （） 条件运算符(? : ;) ) ;运算符是有优先级;
- 流程控制: 条件结构,循环结构，嵌套循环，关键字:break.continue等
- 数组结构: 一维数组 二维数组 数组+循环解决一些数学问题和简单的算法;
- 建议 ：每周做一个总结，可以word格式，ppt格式，也可以是思维导图?
1.2 作业讲解
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 方法的调用
denglu();
}
/**
* 登录的方法 扩展 如果用户登陆失败，一直登陆，3次后程序退出
*/
public static void denglu() {
// TODO Auto-generated method stub
while (true) {
System.out.println("请输入用户名 密码...");
String username = "admin";
String userpwd = "pwd123";
Scanner input = new Scanner(System.in);
String usernameinput = input.nextLine();
String userpwdinput = input.nextLine();
// 用户输入的值如果是admin
if (usernameinput.equals(username) && userpwd.equals(userpwdinput)) {
System.out.println("登陆成功");
// 去菜单页面
caidan();
} else {
System.out.println("登陆失败");
}
}
}
/**
* 菜单的方法
*/
public static void caidan() {
// TODO Auto-generated method stub
while (true) {
System.out.println("请输入您的操作:0 退出 1 最大值 2 最小值 3 排序 ");
Scanner input = new Scanner(System.in);
int n = input.nextInt();
switch (n) {
case 0:
// 终止虚拟机
System.exit(0);
break;
case 1:
zuidazhi();
break;
case 3:
mySort();
break;
default:
System.out.println("输入错误，请重新输入");
break;
}
}
}
/**
* 求最值得方法
*/
public static void zuidazhi() {
// TODO Auto-generated method stub
int weight[] = new int[5]; // 5 =>0
// 定义一个循环去接收用户输入的值
Scanner input = new Scanner(System.in);
// 使用max和剩下的每一个元素都要比较一下
for (int i = 0; i < weight.length; i++) {
System.out.println("请输入第" + (i + 1) + "个值");
weight[i] = input.nextInt();
}
// 假设数组中的第一个元素是最大值(这个数组元素一定是数组中真实的数据值，而不是默认值)
int max = weight[0];
int min = weight[0];
for (int i = 1; i < weight.length; i++) {
// 如果数组中的其他元素比 max还大的话，那么就将这个数组元素赋值给max
// 如果是最小值的话，这里的> 变成 <
if (weight[i] > max) {
max = weight[i];
}
if (weight[i] < min) {
min = weight[i];
}
}
// input.close();
System.out.println("max :" + max + ",min :" + min);
}
/**
* 排序的方法
*/
public static void mySort() {
// 定义数组并赋值
int array[] = { -1, 99, 66, 7, -90 };
// 比较几轮?
// 定义一个循环来表示比较的轮数 4轮-> 数组长度-1
for (int i = 0; i < array.length - 1; i++) {
// 每一轮比较了几次?
for (int j = 0; j < array.length - i - 1; j++) {
// 比较
if (array[j] > array[j + 1]) {
// 交换
int t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
}
}
}
System.out.println("冒泡排序结束后的结果");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
以上代码不完整，具体请自己去扩展和完成
1.3 类和对象:
1.4 面向对象:
面向对象的设计可以理解为:
将数据及对数据的操作封装在一起，成为一个不可分割的整体。同时将具有相同特征的对象抽象成一种新的数据类型—类; 通过对象间的消息传递使整个系统运转，通过类的继承实现代码重用。
面向对象和过程:
| cc | 面向过程 | 面向对象 |
|---|---|---|
| 设计思路 | 自顶向下、层次化、分解 | 自底向上、对象化、综合 |
| 程序单元 | 函数模块 | 对象 |
| 设计方法 | 程序 = 算法 + 数据结构 | 程序 = 对象 = 数据 + 方法 |
| 优点 | 相互独立，代码共享 | 接近人的思维方式 模拟客观世界 |
| 缺点 | 数据与程序不一致维护困难 | 客观世界的无序性概念不成熟 |
1.4.1 类的概念:
类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元，最基本的类由一组结构化的数据和在其上的一组操作构成。
将多个对象中公共的部分(只关注其中相同或者相似)提取出来(提取的过程，称为抽象);形成一个集合，这个集合，理解为一些对象的公共特征和行为，称为类; 类是一个模板，是一个概念性模型，我们可以通过类，得到具体的对象:
类型 引用名 = new 类名();
1.4.2 类的基本结构:
package test;
public class Boy {
// 三个属性
// 属性的语法 修饰符 数据类型 属性名(变量名) =值(默认值) ; 默认值可以省略
// 姓名
// 昵称
// 颜值
String name;
String nicName;
String faceScore;
// 两个方法
// 泡妞
// 帮助别人
// 方法的语法：
// 访问修饰符 修饰符 void无返回值 main方法名(参数列表){}
// public static void main(String[] args) {
// }
// public void helpOthers(数据类型 变量名,数据类型 变量名...)
// {
// }
public void helpOthers() {
System.out.println(nicName + "是一个好人，有求必应~");
}
public void helpOthers(String other) {
System.out.println(nicName + "是一个好人，他喜欢帮助" + other);
}
public void pursueGirl() {
System.out.println(nicName + "是一个好人，他喜欢刘亦菲~");
}
public void pursueGirl(String somebody) {
System.out.println(nicName + "是一个好人，他喜欢泡" + somebody);
}
}
1.4.3 对象的概念：
Java中万事万物皆对象(存在的可以被描述的任何事物),事实上，Java离完全的面向对象编程语言还有最后的一小步距离，因为Java中存在基本数据类型，(Java用包装类型来解决).
现实世界的对象:在座的每个同学都是对象; 电脑:每一台电脑都是一个对象; 等等
请描述一下你旁边这个男(女)人:
请徐扬 描述一下 伟雄: 乐于助人;英俊潇洒;玉树临风;风流(倜傥);wei哥;
需要将伟雄的一些描述内容 变成: 静态的描述(个人特征)信息 ,动态的描述(行为)信息
伟雄: 静态 名字->吴伟雄, 昵称->wei哥 , 颜值->高,
动态: 风流(泡妞) , 帮助别人( 有困难找wei哥)
徐扬也有类似的特征和行为,很多男生都有….
徐扬: 静态 名字->徐扬, 昵称->豆豆 , 颜值->中,
动态: 风流(泡妞) , 帮助别人( 有困难找豆豆)
具体说 ：个人特征也称为 属性; 行为也称为 方法;
对象依赖于类存在（模板-个体实例）
分析过程先有对象后有类；开发过程先有类后有对象；
类型 引用名 = new 类名();
1.4.4 类和对象关系与区别
类是同等对象的集合与抽象。它是一块创建现实对象的模板。对象是类的实例，对象是面向对象编程的核心部分，是实际存在的具体实体，具有明确定义的状态和行为。
1.5 面向对象特征：
1.5.1 封装:
封装的特性能够让服务提供者把它服务的细节隐藏掉，你只需要提交请求与传递它需要的参数，它就会给你返回结果，而这个结果是如何产生的，经过了多少复杂运算，经过多少次数据读取，你都不用管，只要它给你结果就好了。
1.5.2 封装的实现:
将属性私有化，属性的名字不对外公开，但是外部还要方位私有的属性，我们可以提供公共的方法来访问私有的属性
1.6 类和对象的声明
1.6.1 类的基本格式:
1.6.2 类中的属性定义:
1.6.3 类中方法的定义:
public void helpOthers() {
System.out.println(nicName + "是一个好人，有求必应~");
}
public void helpOthers(String other) {
System.out.println(nicName + "是一个好人，他喜欢帮助" + other);
}
public void pursueGirl() {
System.out.println(nicName + "是一个好人，他喜欢刘亦菲~");
}
public void pursueGirl(String somebody) {
System.out.println(nicName + "是一个好人，他喜欢泡" + somebody);
}
package test;
public class TestMethod {
// 方法
// 修饰符 返回值类型 方法名(参数){}
// 1 方法的参数说明:
// 无返回值, 无参数
public void buyYan() {
System.out.println("去买烟，........");
System.out.println("自己躲到厕所，一包抽完~");
}
// 需要参数 参数 是买烟的条件
// 无返回值, 有参数
public void buyYan(double money) {
System.out.println("去买烟，........,买烟还是上课时间，不爽,我是这么爱学习的人，不学习睡不着觉");
System.out.println("自己躲到厕所，一包抽完~");
}
/// 需要得到他买回来的烟
// 有返回值, 有参数
public String buyYan1(double money) {
System.out.println("去买烟，........,买烟还是上课时间，不爽,我是这么爱学习的人，不学习睡不着觉");
return "烟"+"软中华";
}
// 需要参数 参数 是买烟的条件
// 有返回值, 无参数
public String buyYan2() {
System.out.println("去买烟，........,买烟还是上课时间，不爽,我是这么爱学习的人，不学习睡不着觉");
return "烟"+"软中华";
}
}
1.6.4 求两个数字中的最大值:
1.6.5 课堂作业:
使用无参数，无返回值/无参数,有返回值/有参数，无返回值/有参数，有参数/有返回值，完成同样的 求两个数字的最大值?
请使用带参数，带返回值的方法实现求一个数字是否是质数;
关于return
一个方法中的return最多只能执行一次，return意味这个方法的执行已经终止;
这个方法的后续代码将不会执行
1.6.6 对象的创建:
类名 引用名 = new 类名();
1.6.7 属性和方法的调用:
方法的调用
package test;
public class TestBoy {
public static void main(String[] args) {
// TODO Auto-generated method stub
Boy boy1 = new Boy();
// boy1是谁?
// 对象名(引用名).属性
boy1.name = "徐扬";
boy1.nicName = "徐豆豆";
boy1.faceScore = "中";
Boy boy2 = new Boy();
// boy2是谁?
boy2.name = "吴伟雄";
boy2.nicName = "wei哥";
boy2.faceScore = "高";
// 调用方法
// 对象名(引用名).方法名(参数);
boy1.helpOthers();
boy1.pursueGirl();
boy1.pursueGirl("方便面");
boy2.helpOthers();
boy2.pursueGirl();
boy2.pursueGirl("张曼玉");
}
}
1.6.8 成员变量和局部变量:
package test;
public class TestVariable {
// 属性: 全局变量，类的成员属性
// 类成员，整数，没有赋值，默认值是0
// 这个n的值，在当前对象内部是共享
private int n;
public void testMethod01(int n) {
// int n 这换个n当成一个局部变量,他的作用域只能是当前的这个方法
n++;
System.out.println("n :" + n);
}
public void testMethod02() {
// 这里的n是一个全局的变量n
n++;
System.out.println("n :" + n);
}
public static void main(String[] args) {
TestVariable tv = new TestVariable();
int n = 1;
tv.testMethod01(n); // ?2
tv.testMethod02(); // 1
tv.testMethod02(); // 2 ?
}
}
1.6.9 方法的重载:
在一个类中，如果有两(多)个方法,这些方法修饰符，返回值类型，包括方法名都一致，但是参数不同: 例如，参数个数不同;个数相同，但是类型不同;参数个数相同，但是顺序不同(可能);
功能：方法名称的复用，提高代码的可读性；重载是多态的一种表现形式;
System.out.println();
构造方法的重载：
1.6.10 构造方法
package test;
public class Animal {
/**
* 类名和方法名一致,无返回类型
*
* @author Administrator
*
*/
// 私有化的构造方法
/*
* private Animal() {}
*/
// 公共的构造方法
/*
* public Animal() {
*
* }
*/
// 没有访问修饰符的构造方法
/* Animal(){} */
// 带参数 同时私有化的构造
/* private Animal(String name) {} */
// 这个不是构造方法
private void Animal(String name) {
}
// 这个也不是构造方法
private Animal Animal(String name) {
}
// 也不是构造方法
private String Animal(String name) {
}
}
正常情况下，定义一个类，这个类内部会有一个构造方法(构造器);
当我们在一个类中定义一个带参数构造方法的时候，那么这个类中，就有两个构造方法了;
应用场景:当我们给对象中的属性初始化操作的时候，通常会用到构造方法;
构造方法之间相互调用:
1.6.11 this关键字:
构造方法之间相互调用:
代指当前对象
1.6.12 课堂练习:
定义类，在类中定义自我介绍的方法，输出个人信息;包含姓名，性别，年龄，联系方式等.
分析: 将属性定义好，私有化，封装 ; 方法中将个人信息打印出来:
package test;
public class Person {
private String name;
private String sex;
private int age;
private String address;
private String tel;
/**
* 获取name的方法
*
* @return
*/
public String getName() {
return name;
}
/**
* 设置name的方法
*
* @param name
* 用户的名字
*/
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
// 1 直接打印
public void printInfo() {
System.out.println("我是" + name + ",我是" + sex + "的,我今年: " + age + ",我家在" + address + "欢迎大家来做客,如果找不到，请加微信" + tel);
}
// 可以得到个人信息 toString
@Override
public String toString() {
return "Person [name=" + name + ", sex=" + sex + ", age=" + age + ", address=" + address + ", tel=" + tel + "]";
}
}
package test;
public class TestPerson {
public static void main(String[] args) {
Person p = new Person();
p.setAddress("厦门同安影视城");
p.setAge(18);
p.setName("福气");
p.setSex("男");
p.setTel("18860015972");
// 调用自我介绍的方法
p.printInfo();
// 有一个方法 toString ,有一个返回值,String,所以我们调用这个方法的时候要接收返回值
String info = p.toString();
System.out.println(info);
// 还可以不接收，直接调用方法，方法在sysout中调用
System.out.println(p.toString());
// .toString() 省略 ,所以打印一个对象名的时候，默认调用其toString的方法
System.out.println(p);
}
}
定义一个类,BadBoy,这个BadBoy有好几个女朋友，数组来定义，并模拟赋值和输出
定义一个动物类，创建几个动物对象，模拟动物园有一群动物在表演节目.
1.7 总结:
- 面向对象 :类 对象，二者区别，定义类，对象，
- 类中的属性，方法，如何调用
- 方法的重载
- 构造方法
1.8 作业：
课后作业:
1. 定义一个管理员类：
•显示管理员信息的方法：返回管理员用户名和密码的信息；
•验证用户密码的方法：传入用户名和密码的参数，返回布尔类型，用户名和密码是否正确。
•编写一个测试类，创建一个管理员类对象，初始化设置用户名和密码，控制台接收用户输入的用户名和密码，调用验证的方法，显示是否登录成功。
2. 自定义方法，判断一个数字是否是质数，要求有参数(要判断的数字是几 int n)有返回值（是否是质数 boolean）。
3. 自定义方法，判断一个字符串是否是回文，要求有参数(参数就是一个字符串)无返回值(方法中直接输出结果)。
4. 定义一个方法，模拟鸡叫声三种方法实现(重载) ; 自由发挥;
5. 定义一个动物园，有很多动物，动物园动物可以进行表演。要求:使用重载和构造;
6. 自定义类和对象，描述两个人吵架。