(07)Java学习笔记——面向对象01

面向过程——面向过程思想，强调的是过程（动作）。

面向对象——面向对象思想，强调的是对象（实体）,然后由对象去调用功能。

面向对象的特点：

1/面向对象就是一种常见的思想，符合人们的思考习惯。

2/面向对象的出现将复杂的问题简单化。

3/面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

如何才能更符合面向对象思想呢？：

a/有哪些类？

——a/ 呵呵分析有哪些类呢？UML,名词提取法。

b/每个类有哪些东西？

c/类与类之间的关系是什么？

例如：

把大象装进冰箱的分析：

a/ 有哪些类？

大象 冰箱
Demo

b/每个类有哪些东西呢？

大象：进去

冰箱：开门 /
关门

Demo: main方法

c/类与类之间的关系是什么呢？

Demo中使用大象和冰箱类的功能。

代码体现：

class Demo
{
public static void main(String[] args)
{
冰箱调用开门方法；
大象调用装进大象方法；
冰箱调用关门方法；
}
}

calss 大象
{
public static void in()
{
System.out.println("装进大象");
}
}

class 冰箱
{
public static void open()
{
System.out.println("打开冰箱门");
}

public static void close()
{
System.out.println("关闭冰箱门");
}
}


面向对象的开发，设计，特征：

a/ 面向对象开发

就是不断的创建对象，使用对象，指挥对象做事。

b/面向对象设计

就是在管理和维护对象之间的关系。

c/面向对象特征：

封装 /
继承  / 多态

——————————————————————————————————————

类 与 对象的关系

类：

Java语言通过类的形式对事物进行描述。

通过两个方面描绘事物：

1/属性 （成员变量）

2/行为 （成员方法）



成员变量 —— 就是事物的属性 （和以前变量的定义是一样的格式，但是微智不同，在类中方法外）

成员方法 —— 就是事物的行为  

定义类其实就是定义类的成员（成员变量和成员方法）

类与对象之间的关系：

类：事物的描述，相关属性和行为的集合，是一个抽象概念。

对象：该类事物的具体表现形式，具体存在的个体。在java中通过new来创建的。

如何定义一个类：

范例：定义一个学生类

//定义一个学生类
calss student
{
//定义成员变量
//姓名
String name;
//年龄
int age;
//地址
String address;

//定义成员方法
//学习
public void study()
{
System.out.println("学生爱学习");
}

//吃饭
public void study()
{
System.out.println("学生吃饭");
}

//睡觉
public void sleep()
{
System.out.println("学生睡觉");
}
}

如何使用一个类：
创建对象使用类

格式：

类名  对象名 = new 类名（）；

如何使用成员变量？

格式：

对象名 . 变量名；

如何使用成员方法？

格式：

对象名 . 方法名（参数）；

范例：学生类

//定义一个学生类
class student
{
//定义成员变量
//姓名
String name;
//年龄
int age;
//地址
String address;

//定义成员方法
//学习
public void study()
{
System.out.println("学生爱学习");
}

//吃饭
public void eat()
{
System.out.println("学生吃饭");
}

//睡觉
public void sleep()
{
System.out.println("学生睡觉");
}
}

class studentDemo
{
public static void main(String[] args)
{
student s = new student(); // 创建一个学生对象 格式：类名 对象名 = new 类名（）；

System.out.println(s.name+"----"+s.age+"----"+s.address); //输出成员初始变量值（使用成员变量 格式：类名.成员名；）

//给成员变量赋值
s.name = "阿朱";
s.age = 18;
s.address = "解放大街";

System.out.println(s.name+"----"+s.age+"----"+s.address); //赋值后输出

//调用方法
s.study(); //调用类的方法，格式：类名.方法名();
s.eat();
s.sleep();
}
}

范例：对“小汽车“的描述：

/*
描述小汽车
分析：
1/属性：轮胎数，颜色
2/行为：运行
*/

class  ObjectDemo
{
public static void main(String[] args)
{
Car c = new Car();	//在计算机中创建一个car的实例。通过new关键字来创建。Car是一个类（下面定义的用来描述的类）， c就是一个类类型的引用变量，指向了该类的对象。

c.num=4;		//对对象的变量赋值
c.color="red";	//对对象的变量赋值
c.run();	//要使用对象中的内容可以通过  对象.成员 的形式来完成调用。

}
}

class Car	//通过创建一个类，来描述一个事物。
{
int num;	//属性：通过函数来定义。函数定义属性。（成员变量）
String color;

void run()		//行为：通过函数来定义。函数定义一个功能。（成员函数）

{
System.out.println(num+"...."+color);
}

}

——————————————————————————————————————————————————————————————

成员变量和局部变量的区别：

1/成员变量定义在类中，方法外。

局部变量定义在方法，语句，局部代码块中，只在所属的区域有效。

2/成员变量存在于堆内存的对象中

局部变量存在于栈内存的方法中

3/成员变量随着对象的创建而存在，随着对象的消失而消失

局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

4/成员变量都有默认初始化值

局部变量没有默认初始化值，必须定于赋值才能使用。

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

范例：

class VariableDemo_01
{
public static void main(String[] args)
{
Variable v = new Variable();

System.out.println(v.num); //访问成员变量

v.show();

}
}

class Variable
{
int num; //在类中，方法外变量：成员变量

public void show()
{
int num1=20; //在方法中的变量，局部变量
System.out.println(num1);

int num = 100;
System.out.println(num); //局部变量在方法中使用的时候，采用就近原则，所以这个sum=100
}
}

——————————————————————————————————————

方法的形式参数：
形式参数的问题：

基本类型：形式参数改变不影响实际参数

引用类型：形式参数的改变影响实际参数

如果看到一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象。

范例：

class Demo
{
public int sum(int a, int b)
{
return a+b;
}
}

class Student
{
public void show()
{
System.out.println("学生爱学习");
}
}

class StudentDemo
{ //如果看到一个方法的形式参数是一个类类型（引用类型），这里其实需要的是该类的对象
public void method(Student s) //调用时候，把main方法中的s地址传递到了这里 （Student s = new Student();)
{
s.show();
}
}

class ArgsTest_01
{
public static void main(String[] args)
{
//形式参数是基本类型调用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("---------------------------");

dd13
//形式参数是引用类型的调用
//需求：要调用StudentDemo类中的Method()方法：
StudentDemo sd = new StudentDemo();

//创建学生对象
Student s=new Student();
sd.method(s); //把s的地址给到了这里

}
}

——————————————————————————————————————————————

匿名对象

没有名字的对象。

new Car();    //匿名对象，其实就是定义对象的简写格式。

匿名对象调用方法格式：

new 类名() . 方法名()

new Car().run();   

当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

范例：

class Student
{
public void show()
{
System.out.println("我爱学习");
}
}

class NoNameDemo_01
{
public static void main(String[] args)
{
//带名字的对象调用方法
Student s = new Student();
s.show();

System.out.println("---------------------------");

//匿名对象调用方法
new Student().show();

}
}

匿名对象可以作为实际参数传递。

————————————————————————————————————————————————

封装

指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

private  /* 私有 */  //只在本类中有效，外界不能访问。是一个权限修饰符，用于修饰成员（成员变量和成员方法）。只能修饰成员。

私有仅仅是封装的一种体现。

例：private int age;  //用于修饰类里面的成员。

封装的好处：

1/将变化隔离，将属性隔离，用方法来对属性进行可控。

2/便于使用

3/提高重用性

4/提高安全性

封装的原则：

1/将不需要对外提供的内容都隐藏起来

2/把属性都隐藏，对外提供公共访问的方法。

封装范例：

class Student
{
//定义成员变量
String name;
private int age; //用private 私有修饰成员变量，配合setAge()使用

//定义一个成员方法进行输出
public void show()
{
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
}

//增加一个逻辑校验方法
public void setAge(int a) //对外提供一个公共访问方式，隐藏了属性细节
{
if (a>0 && a<120) //设置Age的范围
{
age = a;
}
else
{
System.out.println("请输入正确的年龄：");
}
}

}

class StudentDemo_03
{
public static void main(String[] args)
{
Student s = new Student();

s.name="阿紫";
s.setAge(44);

s.show();

}
}

private的应用：

特点：

a/ 可以修饰成员（包括成员变量和成员方法）

b/ 被private修饰的成员只能在本类中才能访问

最常见的应用：

1/ 把成员变量用private修饰

2/ 提供对应的getXxx()   和 setXxx()方法对外访问

范例：

class Student
{
//定义成员变量
private String name;
private int age; //用private 私有修饰成员变量，配合setAge()使用

//定义一个成员方法进行输出
public void show()
{
System.out.println("姓名:"+getName());
System.out.println("年龄:"+getAge());
}

//增加一个逻辑校验方法
public void setAge(int a) //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
if (a>0 && a<120) //设置Age的范围
{
age = a;
}
else
{
System.out.println("请输入正确的年龄：");
}
}

public String getName() //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
return name;
}

public void setName(String b) //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
name =b;
}

public int getAge() //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
return age;
}
}

class StudentDemo_03
{
public static void main(String[] args)
{
Student s = new Student();

s.setName("阿朱");
s.setAge(25);

s.show();
}
}

this 关键字

代表当前类的一个对象。 谁调用这个方法，在该方法内部的this就代表谁。

范例：

class Student
{
//定义成员变量
private String name;
private int age; //用private 私有修饰成员变量，配合setAge()使用

//定义一个成员方法进行输出
public void show()
{
System.out.println("姓名:"+getName());
System.out.println("年龄:"+getAge());
}

//增加一个逻辑校验方法
public void setAge(int age) //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
if (age>0 && age<120) //设置Age的范围
{
this.age = age; //用this进行当前类对象引用，它就代表当前类的一个对象。
}
else
{
System.out.println("请输入正确的年龄：");
}
}

public String getName() //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
return name;
}

public void setName(String name) //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
this.name =name;
}

public int getAge() //对外提供一个公共访问方式，隐藏了属性细节 **注意返回值类型
{
return age;
}
}

class StudentDemo_03
{
public static void main(String[] args)
{
Student s = new Student();

s.setName("阿朱");
s.setAge(25);

s.show();
}
}

练习01：一个手机类
/*
手机类：
成员变量：
品牌： String brand;
价格：int price;
颜色： String color;

成员方法：
针对每一个成员变量给出对应的set() 和 get() 方法。

输出：
创建一个对象，通过get()方法输出成员变量的值，这一次结果是：null----0----null
然后通过set()方法给成员变量赋值，再次输出结果，这次的结果是：小米----1999----土豪金

*/

class Photo
{
private String brand;
private int price;
private String color;

public void setBrand(String brand)
{
this.brand = brand;
}

public void setPrice(int price)
{
this.price = price;
}

public void setColor(String color)
{
this.color = color;
}

public String getBrand()
{
return brand;
}

public int getPrice()
{
return price;
}

public String getColor()
{
return color;
}

}

class PhotoTest_01
{
public static void main(String[] args)
{
Photo p = new Photo();
System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());

System.out.println("------------------------------");

p.setBrand("小米");
p.setPrice(1999);
p.setColor("土豪金");

System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());
}
}

————————————————————————————————————————————————————

构造方法

给对象的数据进行初始化

特点：
1/函数名与类名相同

2/不用定义返回值类型，连void都没有

3/没有具体返回值，不用return返回东西

格式范例：

class Student
{
public Student() //构造方法名同类名，且没有返回值类型，
{
System.out.println("这是构造方法");
}
}

class ConstructionDemo
{
public static void main(String[] args)
{
Student s = new Student();
}
}

注意事项和作用：

给对象进行初始化 （创建对象都必须要通过构造函数进行初始化）。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数的区别：

1/构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要该函数功能时才调用。

2/构造函数：对象创建时会调用，只会调用一次

一般函数：对象创建时会依据需要调用多次。

什么时候定义构造函数？

在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。



构造函数的重载：（与函数的重载相似）
可以给不同的对象进行不同的初始化。

class  ConsTest02
{
public static void main(String[] args)
{
Person p = new Person();	//创建第一个对象，调用相应的初始化构造函数
p.speak();
Person p1 = new Person("东东");	//创建第二个对象，调用相应的初始化构造函数
p1.speak();

p1.setName("花花");		//可以重复调用Person类中一般函数
p1.speak();

Person p2 = new Person("小黑",3);	//创建第三个对象，调用相应的初始化构造函数
p2.speak();

}
}

class Person	//定义一个描述人属性的类
{
private String name;	//将属性私有
private int age;		//将属性私有

Person ()				//提供公共借口方法
{
name = "baby";
age = 1;
}

Person (String name01)		//相同的函数名，但是不同的参数类型或者参数个数
{
name = name01;
}

Person (String name02,int age02)	//相同的函数名，但是不同的参数类型或者参数个数
{
name = name02;
age = age02;
}

public void setName(String name01)	//一般方法，可重复调用多次，进行不同的参数赋值
{
name = name01;
}

public void speak()			//创建一个函数描述动作
{
System.out.println(name+"...."+age);
}

}

构造函数可以调用一般方法。一般方法不能调用构造函数。



——————————————————————————————————————————————————————————

类的组成：

A / 成员变量

B / 构造方法

-----| 无参构造方法

-----|带参构造方法

C / 成员方法

-----|setXxx();

-----|getXxx();

_________________________________________________________________________________

练习01：

定义一个类Demo，其中定义一个求两个数据和的方法，定义一个测试类Test,进行测试

class Demo //定义一个类
{
public int sum(int x, int y) //定义类中的一个两数相加的方法
{
return x+y;
}
}

class Test_001
{
public static void main(String[] args)
{
Demo d = new Demo(); //创建一个对象用来调用方法

int result = d.sum(5,8);
System.out.println(result);
}
}

什么时候定义成员变量：
如果这个变量是用来描述这个类的信息的，那么该变量就应该定义为成员变量。如果没有关系，就不要定义为成员变量。

变量的范围越小越好，因为能及时被回收。

练习02：

定义一个长方形类，定义求周长和面积的方法，然后测试

class Rectangle_01
{
private int longside; //将成员变量私有化
private int shortside;

public void setSide(int longside,int shortside) //提供公共的方法给外部对象调用
{
this.longside=longside;
this.shortside=shortside;
}

public Rectangle_01() //构造函数初始化
{
}

public int meter() //定义一个计算周长的方法
{
int m =(longside+shortside)*2;
return m;
}

public int area() //定义一个计算面积方法
{
int ar = longside*shortside;
return ar;
}

}

class RectangleTest_01
{
public static void main(String[] args)
{
Rectangle_01 re = new Rectangle_01(); //定义一个对象用来调用方法

re.setSide(10,5);

int result1 = re.meter();
int result2 = re.area();

System.out.println("长方形的周长是："+result1);
System.out.println("长方形的面积是："+result2);

}
}


练习03：
定义一个员工类，分析类成员，给出成员变量，构造方法，get()  set()方法，及显示成员信息的方法。测试

/*
员工的属性：
成员变量：
员工编号，名字，年龄
成员方法：
set()方法给变量赋值
输出员工信息

*/

class Person
{
private int number;
private String name;
private int age;

public void setNumber(int number)
{
this.number = number;
}

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

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

public void show()
{
System.out.println("编号是"+number+"的这个人是"+name+",他的年龄是"+age);
}

}

class PersonTest_01
{
public static void main(String[] args)
{
Person p = new Person();

p.setNumber(33);
p.setName("阿朱");
p.setAge(26);

p.show();
}
}

————————————————————————————————————