Java day 05
Java day05
面向对象
1. 面向对象与面向过程的区别
面向过程的思想：代表语言 c语言 功能开发的每一步都是自己参与的
面向对象的思想：代表语言 Java语言 指的是不断地创建对象，指挥对象事情过程
-
举例现实生活的例子
喝水：
面向过程的思想：自己拿起水杯，自己走到饮水机前，自己接水
面向对象的思想：祈求同桌接水，同桌拿起水杯，同桌走到饮水机面前，同桌接水 -
伪代码的例子
将大象装进冰箱
面向过程思想：class Demo{ public static void main(String[] args){ //打开冰箱门 //实际上打开冰箱门的功能代码量是很多的 //大象跳进冰箱 //实际上大象跳进冰箱的功能代码量是很多的 //关闭冰箱门 } }补充14:52
面向对象的思想：
- 都有哪些事物？
判断事物的方式
-
UML课程知识
-
名词提取法
大象，冰箱，测试类 -
事物中都有些什么？
大象：
属性：身高，体重，性别…..
行为：跳进冰箱，吃饭，睡觉….
冰箱：
属性：颜色，容量，大小….
行为：打开冰箱门，关闭冰箱门...
测试类：
main方法 -
事物和事物之间的关系是什么？
在测试类中创建大象对象和冰箱对象class 大象{ 身高; 体重; 跳进冰箱(){ //... } 吃饭(){ //... } 睡觉(){ //... } } class 冰箱{ 颜色; 容量; 大小; 打开冰箱门(){ } 关闭冰箱门(){ } } class Test{ public static void main(String[] args){ //创建一个大象对象 //创建一个冰箱对象 //调用冰箱对象中的打开冰箱门的方法 //调用大象对象中的跳进冰箱的方法 //调用冰箱对象中的关闭冰箱门的方法 } } -
类和对象的关系
类：相当于汽车图纸
对象：通过图纸造出来的一辆车 -
面向对象的三大特征：
封装
继承
多态
成员方法和成员变量都在class里,这一个类里
package com.shujia.day05;
import java.util.Scanner;
/*
学生： class Student：
属性：姓名，年龄，性别 成员变量：name,age,gender
行为：吃饭，睡觉 成员方法：eat(){},sleep(){}
*/
public class Student {
//成员变量，定义在类中方法外
String name;
int age;
String gender;
//成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
//这个类里不需要有main方法的,因为这个类只是用来描述student的属性行为的
class Demo1 {//再写一个类,要创建对象啦!!再一个类!
public static void main(String[] args) {
//创建一个学生对象
//如何通过一个类创建一个对象
// 语法格式：类名 对象名 = new 类名();
//new在这里创建了一个新对象
Student s1 = new Student();
//获取对象中的成员变量
//对象名.成员变量名
String n1 = s1.name;
System.out.println("姓名：" + n1);
s1.name = "江川";
System.out.println("姓名：" + s1.name);
//如何使用对象中的成员方法
// eat();
//对象名.成员方法名()
s1.eat();
s1.sleep();
}
}
成员变量和局部变量的区别
- 在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上 - 在内存中的位置不同
成员变量 堆内存
局部变量 栈内存 - 生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失 - 初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
形式参数
当今后看到类做参数时候，调用时需要传入该类的对象【或者该类的字对象】
当你今后看到一个类作为方法的参数的时候，将来调用时需要传入该类的对象【或者该类的子类对象】
package com.shujia.day05;
//定义一个教师类
class Teacher {
public void fun2(){
System.out.println("好好学习，天天向上！");
}
}
class Demo2{
//当你今后看到一个类作为方法的参数的时候，将来调用时需要传入该类的对象【或者该类的子类对象】
public void method(Teacher t){ //Teacher t = new Teacher()
t.fun2();
}
}
public class TeacherDemo1 {
public static void main(String[] args) {
Demo2 d1 = new Demo2();
// Teacher t1 = new Teacher();
d1.method(new Teacher()); // new Teacher()
//匿名对象，指的是没有名字的对象，只能用一次，后续无法继续使用该对象
// d1.method(new Teacher());
}
}
封装：
package com.shujia.day05;
/*
我们按照今天说的类和对象的知识，创建了一个Person对象，并且也成功赋值了姓名和年龄
但是我们可以赋值一些不合实际的数值，这是不应该出现，所以我们应该在赋值之前，要先判断一下要赋的值是否合理
既然是加判断，就不是一句话可以搞定的，我们可以定义一个方法，使用方法对成员变量赋值
我们确实可以通过加一个方法来对成员变量进行赋值，但是谁规定了我必须要用这个方法呢？我们依旧可以使用原来的方式进行赋值
我们如果可以通过一些手段，让外界无法直接获取成员变量，这样就不得不使用方法进行赋值了。
java提供一个关键字给我们使用：private 私有的
private关键字：
可以修饰成员变量，成员方法，构造方法
在同一个类中，private关键字不起作用，相当于透明的，同一个类中被private关键字修饰的成员可以随意访问
说到现在，其实说的就是面向对象编程三大特征之一：封装
封装： 使用private关键字将类中细节进行隐藏，只对外提供公共的访问方式。
一个标准类的写法：最终是4.0版本
1.0版本的写法：使用private关键字修饰成员变量
类：
成员变量：使用private关键字修饰
成员方法：针对每一个成员变量提供对应公共的setXxx()和getXxx()
*/
class Person {
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String n){
name = n;
}
public int getAge(){
return age;
}
public void setAge(int i) {
if (i > 0 && i <= 130) {
age = i;
}else {
System.out.println("输入的年龄不合实际！");
}
}
private void fun1(){
System.out.println("好好学习，天天向上！");
}
public void show1(){
fun1();
}
}
public class PersonDemo {
public static void main(String[] args) {
//创建一个Person类的对象
Person p1 = new Person();
// System.out.println("姓名：" + p1.name);
// System.out.println("年龄：" + p1.age);
System.out.println("姓名：" + p1.getName());
System.out.println("年龄：" + p1.getAge());
System.out.println("-------------------------");
// p1.name = "江川";
// p1.age = 1800;
p1.setAge(1800);
p1.setName("江川");
// System.out.println("姓名：" + p1.name);
// System.out.println("年龄：" + p1.age);
System.out.println("姓名：" + p1.getName());
System.out.println("年龄：" + p1.getAge());
System.out.println("------------------------");
// p1.fun1();
p1.show1();
}
}
