面向对象编程思想
一、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);
}