(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("---------------------------");
//形式参数是引用类型的调用
//需求：要调用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();
}
}————————————————————————————————————