面向对象思想就是将生活客观存在的事物,通过代码的形式将其描述出来。当我们再看到这些对象的时候,就联想到他应该具有什么样的功能
比如:
洗衣机可以洗衣服,甩干,烘干
学生可以吃饭,睡觉,学习
可以描述生活中所有的事物
** 类的组成**
属性:指事物的特征。例如:狗事物(品种、价格、年龄等)
行为(方法):指事物能执行的操作,例如:狗事物(吃东西、睡觉、看家)
在代码中,属性是通过成员变量体现的。行为是通过成员方法来体现的。
概念:
就是真实世界中的实体,现实世界中每个实体都是一个对象,是一种具体都概念
特点:
对象具有属性和行为。
对象具有变化的状态。
对象具有唯一性。
对象都是某个类别的实例。
一切皆为对象,真实世界中的所有事物都可以视为对象。
//普通
public void 方法名() {
// 方法体
}
//带参数
public void 方法名 ( 数据类型 变量名) {
// 方法体
}
//带返回值
public 数据类型 方法名() {
// 方法体
return 返回值;
}
//及带参数又带返回值
public 数据类型 方法名 (数据类型 变量名1,数据类型 变量名2...) {
//方法体
return 返回值;//将方法的运行结果返回给调用者
}
//方法的通用格式(掌握)
public static 返回值类型 方法名(参数) {
方法体;
return 数据 ;
}
/*
格式详解:
public static 修饰符,目前先记住这个格式
返回值类型 方法操作完毕之后返回的数据的数据类型,如果方法操作完毕,没有数据返回,这里写void,而且方法体中一般不写return
方法名 调用方法时候使用的标识
参数 由数据类型和变量名组成,多个参数之间用逗号隔开
方法体 完成功能的代码块
return 如果方法操作完毕,有数据返回,用于把数据返回给调用者
定义方法时,要做到两个明确
明确返回值类型:
主要是明确方法操作完毕之后是否有数据返回。
如果没有,写void。
如果有,写对应的数据类型。
明确参数:
主要是明确参数的类型和数量
调用方法时的注意:
void类型的方法,直接调用即可
非void类型的方法,推荐用变量接收调用
* */
注:
1.可以带多个参数用逗号隔开
2.返回值类型可以为:
a;基本类型
b.数组
c.字符串
d.自定义的类
对象名.方法名();
public class Student {
//属性
String name;
int age;
//行为 --- 学习
public void study(){
System.out.println(name + "学生学习Java");
}
//行为 --- 吃饭
public void eat(){
System.out.println(name + "学生吃饭");
}
//行为 --- 睡觉
public void sleep(){
System.out.println(name + "学生睡觉");
}
}
public class Lianxi {
/*
成员方法的调用格式:
对象名.方法名();
*/
public static void main(String[] args) {
Student stu = new Student();
stu.name = "张三";
stu.age = 23;
System.out.println(stu.name + "今年:" + stu.age + "岁");
stu.sleep();
stu.eat();
stu.study();
}
}
对象名.方法名(参数);
形参:全称形式参数,是指在定义方法时,所声明的参数
实参:全称实际参数,调用方法时,所传入的参数
public class Phone {
String brand;
int price;
//定义带有参数的方法
public void call(String name){//String name就是形参
System.out.println("给" + name + "打电话");
}
//定义没有参数的方法
public void sendMessage(){
System.out.println("群发短信");
}
}
public class Lianxi {
public static void main(String[] args) {
Phone p = new Phone();
//有参数的方法调用格式: 对象名.方法名(参数);
p.call("张三"); //张三就是实参
p.call("李四"); //李四也是实参
//没有参数的方法调用格式: 对象名.方法名();
p.sendMessage();
}
}
方法定义时,参数中的数据类型与变量名都不能缺少,缺少任意一个程序将报错
方法定义时,多个参数之间使用逗号分隔
方法调用时,参数的数量与类型必须与方法定义中的设置相匹配,否则程序将报错
数据类型 变量名 = 对象名.方法名(参数...);//相当于就是拿一个变量接收一下方法的运行结果。
public class Phone {
String brand;
int price;
//有参有返回值的方法
public int add(int a, int b){
int c = a + b;
return c;
}
}
public class TestPhone {
public static void main(String[] args) {
Phone p = new Phone();
//调用有参有返回值的方法。
//必须拿一个变量接收一下方法的运行结果。
int result = p.add(10,20);
System.out.println(result);
}
}
提高代码的复用性
提高代码的可阅读性
方法必须先创建才可以使用,该过程称为方法定义
方法不调用就不执行
方法与方法之间是平级关系,不能嵌套定义
方法的定义顺序和执行顺序无关
方法的返回值类型为void,表示该方法没有返回值,没有返回值的方法可以省略return语句不写如果要编写return,后面不能跟具体的数据。
return语句下面,不能编写代码,因为永远执行不到,属于无效的代码
this修饰的变量用于指代成员变量,其主要作用是(区分局部变量和成员变量的重名问题)。
方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
注:在这个重名问题中就引出了一个就近原则
在方法中调用变量,谁离调用者越近,那么方法中就会调用谁。
this关键字就是解决这个问题的
public class Student {
String name;
int age;
public void hello(String name){
// 就近原则 --- 访问局部变量
System.out.println("局部变量" + name);
// 利用this --- 访问成员变量
System.out.println("成员变量" + this.name);
}
public void unm(){
System.out.println("unm方法中的this" + this);
}
}
public class Lianxi {
public static void main(String[] args) {
Student stu = new Student();
stu.name = "张三";
stu.age = 12;
stu.hello("李四");
}
}
this代表当前类的对象引用(地址值)
哪个对象调用this所在的方法,this就代表哪一个对象。
作用:用于区分局部变量和成员变量重名的问题。
this 可以用于调用本类的成员变量和成员方法。
调用成员变量:
如果跟局部变量没有重名,this可以省略。
调用成员方法:
this 可以直接省略。
public class Student {
String name;
int age;
public void study() {
System.out.println("学习");
}
public void sleep() {
System.out.println("睡觉");
}
public void eat() {
System.out.println("吃饭");
}
public void show(){
//如果不存在重名,这里的this可以省略
System.out.println(this.name);
System.out.println(this.age);
//调用其他成员方法,this可以省略。
this.study();
this.sleep();
this.eat();
}
}
public class Lianxi {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
可以修饰类、类成员(包括成员变量和成员方法)
private :只能在本类当中进行访问。使用对象:变量、方法。
(default)默认: 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
protected: 对同一包内的类和所有子类可见。使用对象:变量、方法。
public :权限最大,可在任意位置进行访问。使用对象:类、接口、变量、方法
方法重载指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载。
多个方法在同一个类中。
多个方法具有相同的方法名。
多个方法参数的数量不同、类型不同或者数据类型的顺序不相同。
好处:
在编写代码时,不需要起那么多方法名了,相同功能的方法,名字可以一样。
在调用方法时,不用记忆过多繁琐的方法名字。
注意事项:
重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判定两个方法是否相互构成重载
public class Lianxi {
public int unm(int a, int b) {
return a + b;
}
public double unm(double a, double b) {
return a + b;
}
public int unm(int a, int b, int c) {
return a + b + c;
}
public double unm(double a, double b, double c) {
return a + b + c;
}
}
注:数据类型的顺序不同可以构成重载,但是不建议
方法名与类名相同,大小写也要一致
没有返回值类型,连void都没有
没有具体的返回值(不能由retrun带回结果数据)
用的于给对象的数据(属性)进行初始化
创建对象的时候调用,每创建一次对象,就会执行一次构造方法
不能手动调用构造方法
注:当没有写构造函数的时候有默认空参构造函数
构造方法的创建 :
如果没有定义构造方法,系统将给出一个默认的无参数构造方法。
如果定义了构造方法,系统将不再提供默认的构造方法。
构造方法的重载:
如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法。
建议 :
无论是否使用,都手动书写无参数构造方法,和带参数构造方法。
隐藏实现细节,仅对外暴露公共的访问方式
常见的体现:
将代码抽取到方法中,这是对代码的一种封装
将属性抽取到类当中,这是对数据的一种封装
/*不封装数据,那么3个学生信息需要操作6个数据。
把姓名和年龄封装成一个Student对象再进行操作。这样我们只要操作3个数据即可。
那如果1个学生对象有10个属性呢?
如果不封装,3个学生对象要操作30个数据。
如果封装,3个学生对象依旧只要操作3个数据即可。*/
//把属性抽取到类当中,这是对数据的一种封装
public class Student {
String name;
int age;
}
public class Lianxi{
public static void main(String[] args){
//情况一:不封装数据
//第一组学生信息
String name1 = "张三";
int age1 = 23;
//第二组学生信息
String name2 = "李四";
int age2 = 24;
//第三组学生信息
String name3 = "王五";
int age3 = 25;
//情况二:把姓名和年龄封装成一个Student对象再进行操作
Student stu1 = new Student();
stu1.setName("张三");
stu1.setAge(23);
Student stu2 = new Student();
stu2.setName("李四");
stu2.setAge(24);
Student stu3 = new Student();
stu3.setName("王五");
stu3.setAge(25);
}
}
这样提高了代码的复用性
一个标准的JavaBean类包含以下几个部分:
成员变量:使用 private 修饰
构造方法:
提供一个无参构造方法
提供一个带多个参数的构造方法
成员方法 :
提供每一个成员变量对应的 setXxx() / getXxx()
使用JavaBean类:
利用无参构造创建对象,使用 setXxx() 赋值
利用带参构造方法直接创建带有属性值的对象
class Dog{
private String name;
private long phone;
private char sex;
public Dog(String name, long phone, char sex) {
this.name = name;
this.phone = phone;
this.sex = sex;
}
public Dog(){}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getPhone() {
return phone;
}
public void setPhone(long phone) {
this.phone = phone;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
public class lianxi {
public static void main(String[] args) {
Student student = new Student();
}
}
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/zhjjly/article/details/121451766
内容来源于网络,如有侵权,请联系作者删除!