面向对象编程思想
一、OOP
1、oop
面向对象编程
2、oop是Java语言编程思想
这种思想指导我们程序员如何使用Java写代码。
3、面向对象和面向过程区别
面象过程：强调的是解决问题的步骤，直接写函数即可，直接调用函数:函数名(..)。
面向对象：强调使用对象解决问题，对象是属性和方法的综合体，使用对象名.属性名和对象名.方法名(..)。
4、oop编程
倒推：
使用对象解决问题；
需要对象；
创建一个对象；
对象是什么样的呢？
我们需要告诉计算机，对象是什么样的，有哪些功能。
提供模板：类。
类：创建对象的模板。
对象：是类的具体化。
对象是一个独立的个体。
根据问题，进行分析；
通过分析，定义模板（抽象成类）；
通过类，创建对象（实例化，实例=对象）；
使用对象的属性和方法，解决问题。
5、oop应用
问题：
老于是一个胖子，体重200公斤。为了女朋友决定减肥，通过不懈的努力，体重将为100公斤。
分析，抽象成类：
人类{
属性：姓名，体重
方法：减肥（体重由200变成100）
}
通过类，创建对象：
类名 对象名=new 类名（）；
通过对象，解决问题：
对象名.属性名 保存数据
对象名.方法名(..) 解决问题的过程
二、类的定义
1、语法：
[修饰符] class 类名{
//定义属性:成员变量
//初始值：常量，所有对象值相同
[修饰符] 数据类型 属性名[=初始值];
//赋值语句错误：属性名=初始值
//初始化语句，必须写到方法体内或初始化块中。
//定义方法：成员方法
[修饰符] 返回值类型 方法名([参数]){
//方法体：解决问题的过程
}
//定义构造器
[修饰符] 类名([参数]){
//方法体：属性初始化
}
}
public class Person {
//属性:成员变量
public String name;
public double weight;
//方法：成员方法
public void loseWeight(){
System.out.println("原始体重："+weight);
weight=100;
System.out.println("减肥后的体重:"+weight);
}
}
三、创建对象
创建对象，其实就是在堆里开辟一个大空间。
里面包含属性和方法。
这些属性和方法，是参考类赋予的。
1、语法：
类名 对象名=new 类名();
int[] 数组名=new int[4];
//主方法：程序执行的入口
public static void main(String[] args) {
// 使用类名声明一个变量，表示改变量存储的是该类型的对象的首地址（堆）。
// new Person();
// 在堆里开辟空间
// 以类作为模板，赋予对象属性和方法
// 返回对象在堆里的首地址
// 将地址赋给p1
Person p1=new Person();
Person p2=new Person();
}
每new一次，都会产生一个新对象，在堆内存中存储。
2、原理
jvm先加载类的信息到内存的方法区中。
在堆内存中开发空间，保存对象的信息。
然后以类为模板创建对象，类中有哪些属性和方法，就会给对象添加那些属性和方法。
四、使用对象
1、语法：
对象名.属性名
对象名.方法名(..)
p.name="老于";
p.weight=200;
p.jianfei();
p2.name="老王";
p2.weight=300;
p2.jianfei();
2、原理
p.jianfei();
通过p中保存的首地址，找到对应的堆内存中的对象。
然后，找到该对象中的属性和方法；
最后执行属性和方法体。
五、基本类型和引用类型
1、基本数据类型
基本类型的变量存储是单一值。
2、引用数据类型
引用类型的变量中存储的是对象的首地址。
数组：数组对象内部分为若干元素，每个元素可以存储一条数据。
数组名.length，length并不是属性，length是计数器中记录数组的长度。
类：类类型的对象内部分为属性和方法。
接口：在类类型的基础上，会向上转型。
六、变量
1、变量
Java中用于存储数据的容器。
变量的特点：存储的数据是可以变化（修改）。
2、变量的分类
Java语言中，变量分为局部变量和成员变量（对象的属性）。
局部变量：声明在方法体内的变量。不属于任何对象。
成员变量：声明在类中，方法体外的变量。是对象的属性。
3、局部变量和成员变量的区别
（1）声明的位置
局部变量：声明在方法体内的变量。
成员变量：声明在类中，方法体外的变量。
（2）作用范围
局部变量：只能用于声明它的方法体内，其他方法体无法访问。
成员变量：可以作用于当前类的所有方法体内。
（3）缺省值
成员变量：有缺省值。
byte short int long 0
float double 0.0
char 空白字符
boolean false
引用类型 null
局部变量：没有缺省值。
null的含义：null是一种引用类型的数据，表示没有对象的地址！！！
（4）修饰符
成员变量：可以使用任何修饰符修饰。（public protected private 不写） static final ==
局部变量：只能使用final。
（5）重名问题
局部变量（或参数）之间如果作用范围有交集，不能重名；
成员变量之间如果作用范围有交集，不能重名；
成员变量和局部变量（或参数）是可以重名的！！
public class Person2 {
public String a;
public double b;
public int c;
public char d;
public boolean e;
public static void main(String[] args) {
Person2 pp=new Person2();
System.out.println(pp.a);
System.out.println(pp.b);
System.out.println(pp.c);
System.out.println(pp.d);
System.out.println(pp.e);
final int f=10;
}
}
七、方法参数
1、语法
[修饰符] 返回值类型 方法名([参数]){
//方法体：解决问题的过程
}
2、方法的作用和调用
（1）作用
所谓方法，就是一个有名字的语句组。
方法体，解决问题的过程。
（2）调用
我们可以通过对象名.方法名(..)调用某个方法。
调用方法，就是执行方法体中的代码。执行完毕，方法的调用语句结束。
3、方法的参数
（1）作用
可以根据用户的需要，每次调用方法时，都可以向方法体内传入变化的数据。
（2）参数定义
参数定义在方法名后小括号中。
一个方法，可以定义0到多个参数。
每一个参数：【final】 数据类型 参数名 ， 多个参数中间使用逗号分隔。
（3）传参
方法调用时，在小括号中给对应的参数赋值。不能使用=号符号。
调用一个方法时，方法有参数，有几个参数就必须传几个值，并且类型和顺序一致。
传入的数据：实参。
定义的参数：形参。
//类的定义
public class Person {
// 属性的定义
public String name;
public double weight;
//方法的定义
public void jianfei(){
//方法体，解决问题的过程
System.out.println(name+"开始体重为"+weight);
weight=100;
System.out.println("经过不懈的努力，体重减为"+weight);
}
public void jianfei(double w,int a){
//方法体，解决问题的过程
System.out.println(name+"开始体重为"+weight);
weight=w;
System.out.println("经过不懈的努力，体重减为"+weight);
}
//主方法：程序执行的入口
public static void main(String[] args) {
Person p=new Person();
Person p2=new Person();
p.name="老于";
p.weight=200;
p.jianfei();
p2.name="老王";
p2.weight=300;
p2.jianfei();
p2.jianfei(80,10);
p2.jianfei(90,20);
}
}
4、属性和参数的区别
属性：对象的数据。随对象长久存在
参数：方法体内的数据。方法调用时存在，执行完毕销毁。临时的局部变量。
八、方法的重载overload
1、定义
在同一个类中，多个方法的方法名相同但是参数必须不同的现象。
2、参数不同的情况：
（1）参数个数不同
（2）参数个数相同：对应顺序的类型至少有一个不同。
参数名不能作为判断的依据，因为调用时跟参数名无关！！
3、案例
public class JiSuanQi {
public void jia(int a,int b){
System.out.println(11);
System.out.println(a+b);
}
public void jia(double a,double b){
System.out.println(22);
System.out.println(a+b);
}
// public void jia(double c,double d){
// System.out.println(d+c);
// }
public void jia(double a,int b){
System.out.println(33);
System.out.println(a+b);
}
public void jia(int a,double b){
System.out.println(44);
System.out.println(a+b);
}
public void jia(int a,int b,int c){
System.out.println(55);
System.out.println(a+b+c);
}
public void jian(double a,double b){
System.out.println(a-b);
}
public static void main(String[] args) {
JiSuanQi jsq=new JiSuanQi();
jsq.jia(10,20);
jsq.jia(10.0,20.0);
jsq.jia(10,20.0);
jsq.jia(10.0,20);
jsq.jia(10,20,30);
jsq.jian(10,20);
}
}
九、方法的返回值类型
1、返回值
方法调用结束时，向外输出一条数据。这条数据就叫返回值。
调用后，返回值可以在后面的程序中使用。
2、无返回值类型
不返回数据。
使用关键字void表示。
3、有返回值类型
使用具体的数据类型表示。
一旦定义了一个方法有返回值，这个方法执行结束必须返回一条该类型的数据。
返回值语句：
return 数据;
返回值和打印区别：
完全是没有任何交集的两个东西。
返回值作用，将方法体内的数据输出，供调用结束后，后面的程序获取和使用。
打印，将数据显示在控制台上。
4、return语句
（1）第一种
return 数据；
用在有返回值的方法体中。
返回一条数据，然后结束方法体。
（2）第二种
return;
用在没有返回值的方法体。
不返回数据，仅仅表示方法体执行的结束。
public class JiSuanQi2 {
public void jia(int a,int b){
int sum=a+b;
System.out.println(sum);
}
public int jia2(int a,int b){
int sum=a+b;
return sum;
}
public static void main(String[] args) {
JiSuanQi2 j2=new JiSuanQi2();
j2.jia(10,20);
// int ss2=j2.jia(10,20);
int ss=j2.jia2(10,20);
System.out.println(ss);
}
}
5、return和打印语句的区别
return 返回一条数据供后续程序使用；没有打印功能。
打印语句 将数据打印到控制台。没有返回值功能。
十、构造器
1、类和对象的关系
类是创建对象的模板。
对象是类的具体化。
2、如何创建类的对象呢？
构造器是创建对象的工具。
构造器是定义在类中，每一个类必须有构造器。
如果你在类中没有定义构造器，系统会提供一个缺省的无参构造器。
3、构造器的定义
语法：
[修饰符] 类名([参数]){
//方法体：对象属性的初始化代码
}
注意：构造器的名字必须和类名相同！！
构造器也叫构造方法，但不是方法。
构造器创建对象的，方法是解决问题的过程。
public class Student {
// 属性
public int number;
public String name;
public String sex;
public int score;
// 方法
public void display(){
System.out.println(number);
System.out.println(name);
System.out.println(sex);
System.out.println(score);
}
//构造器的定义
public Student(){
}
public Student(int num,String nm){
number=num;
name=nm;
}
public Student(int num,String nm,String s,int sr){
number=num;
name=nm;
sex=s;
score=sr;
}
}
4、调用构造器创建对象
类名 对象名=new 构造器名(实参);
执行过程：
/**
* 通过类名在方法区中找到这个类，（如果找不到，现加载类到方法区）
* 在堆中开辟对象空间，
* 将类中的属性和方法，赋予堆中的对象，
* 传参
* 执行方法体
* 返回对象的首地址
*/
5、构造器的重载
在同一个类中定义多个构造器的现象。
他们的参数必须不同，因为构造器的名字和类名必须相同。
构造器的方法体主要用于初始化创建的对象属性。
提供了多种初始化的方案。
十一、this关键字
1、第一种用法
同一个类的成员变量之间不能重名；
局部变量如果作用域有交集，不能重名；
成员变量和局部变量（参数）可以重名。
当参数或局部变量，和成员变量重名时，在方法体中直接访问的是参数或局部变量，成员变量被隐藏。
我们使用this.成员变量名来访问被隐藏的属性。
public class WuMingFen2 {
public String theMa;
public int quantity;
public boolean likeSoup;
public void setTheMa(String theMa){
this.theMa=theMa;
}
public WuMingFen2(String theMa,int quantity,boolean likeSoup){
this.theMa=theMa;
this.quantity=quantity;
this.likeSoup=likeSoup;
}
}
原因：this表示的是当前对象！！！
2、第二种用法
this当前类的构造器！！！
通过在一个构造器中调用另外一个构造器，从而减少构造器中重复代码的编写。
public WuMingFen2(String theMa,int quantity,boolean likeSoup){
this.theMa=theMa;
this.quantity=quantity;
this.likeSoup=likeSoup;
}
public WuMingFen2(String theMa,int quantity){
// this.theMa=theMa;
// this.quantity=quantity;
// likeSoup=true;
//System.out.println();
this(theMa,quantity,true);
}
public WuMingFen2(){
// theMa="酸辣";
// quantity=2;
// likeSoup=true;
this("酸辣",2,true);
}
浙公网安备 33010602011771号