java面向对象方法的回顾

1.1 方法的回顾
1.1.1 案例代码一:

package com.itheima_01;
/*
 * 需求:定义一个方法求两个数的和,并在主方法中调用
 *
 * 方法:类中的一段具有特定功能的程序,提高了代码的复用性和可维护性
 * 定义格式:
 * public static 返回值类型(没有返回值写void) 方法名(参数类型 参数名,参数类型 参数名2) {//形参
 * 方法体;
 * }
 * 调用方式:
 * 有明确返回值类型:
 * 赋值调用,将方法的返回值赋值给一个变量
 * 输出调用,使用输出语句直接输出方法的返回值
 * 直接调用,没法获取方法的返回值
 * 没有明确返回值类型:
 * 直接调用
 * 方法重载:在一个类中有多个重名的方法,这些方法参数不同,和返回值无关
 *
 * 注意:
 * 形参:方法声明的变量,只能是变量,接收方法调用时传递进来的数据
 * 实参:调用方法时传递的数据,可以是常量也可以是变量
 *
 */
public class MethoDemo {
public static void main(String[] args) {
//赋值调用
//int sum = sum(10,20);//实参
//System.out.println(sum);
//输出调用
int a = 10;
int b = 20;
System.out.println(sum(a,b));
}
public static int sum(int a,int b) {
/*        //使用变量接收求和结果并返回
int sum = a + b;
return sum;*/
//直接返回求和结果
return a + b;
}
}

1.2 数组的回顾
1.2.1 案例代码二:

package com.itheima_02;
/*
 * 需求:定义一个元素类型为int的数组,遍历数组并求和
 *
 * 数组:用于存储多个元素的一种容器
 * 数组的特点:
 * 元素类型必须一致
 * 元素有整数索引
 * 一旦定义好长度则无法改变
 * 可以存储基本数据类型
 * 也可以存储引用数据类型
 * 定义格式:
 * 动态初始化
 * 元素类型[] 数组名 = new 元素类型[10];
 * 静态初始化
 * 元素类型[] 数组名 = {元素1,元素2,元素3};
 * 元素类型[] 数组名  = new 元素类型[]{元素1,元素2,元素3};
 *
 */
public class ArrayDemo {
public static void main(String[] args) {
//使用静态初始化定义数组
int[] arr = {1,2,3,4,5};
//定义一个变量用于存储求和结果
int sum = 0;
//遍历数组
for(int x = 0;x < arr.length;x++) {
sum += arr[x];
}
System.out.println(sum);
}

}

1.3 标准类定义和使用回顾
1.3.1 案例代码三:

package com.itheima_03;
/*
 * 定义一个标准的学生类,在主方法中创建对象并调用
 * 姓名,年龄,性别3个成员变量
 * 无参,有参两个构造方法
 * 为每个成员变量定义getter/setter方法
 * 定义一个show方法,输出成员变量
 */
public class Student {
private String name;//姓名
private int age;//年龄
private String gender;//性别
/*//无参构造
public Student() {}
//有参构造
public Student(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//name
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//age
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//gender
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}*/
//show:用于输出所有的成员变量
public void show() {
System.out.println(name + "," + age + "," + gender);
}

public Student() {
super();
// TODO Auto-generated constructor stub
}

public Student(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}

public String getName() {
return name;
}

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

public int getAge() {
return age;
}

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

public String getGender() {
return gender;
}

public void setGender(String gender) {
this.gender = gender;
}
}

package com.itheima_03;

public class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//为成员变量进行赋值
s.setName("张三");
s.setAge(18);
s.setGender("男");
s.show();
System.out.println("----------");
Student s2 = new Student("李四",20,"其他");
//s2.show();
System.out.println(s2.getName());
}
}

原文地址:http://blog.51cto.com/13587708/2087124

时间: 2024-11-10 11:09:23

java面向对象方法的回顾的相关文章

Java面向对象-方法的重载

Java面向对象-方法的重载 所谓方法的重载, 类里面有两个或者多个重名的方法,但是方法的参数个数.类型.顺序至少有一个不一样,这时候局构成方法重载: 上代码: 1 package com.java1234.chap03.sec03; 2 3 public class Demo01 { 4 5 int add(int a,int b){ 6 System.out.println("方法一"); 7 return a+b; 8 } 9 10 /** 11 * 方法的重载,参数个数不一样

Java面向对象-方法的值传递和引用传递

Java面向对象-方法的值传递和引用传递 方法的值传递: 值传递 在方法里改变变量的值 作用范围仅仅是方法里 对外面不影响: 上代码: 1 package com.java1234.chap03.sec03; 2 3 public class Person { 4 5 void speak(int age){ 6 System.out.println("我今年"+age+"岁了"); 7 age=24; // 作用范围是方法里 8 } 9 10 public sta

Java面向对象-方法的定义及简单使用

Java面向对象之方法 方法是对象的一部分,也称为行为: 先来一个简单实例: 1 package com.java1234.chap03.sec03; 2 3 public class Person { 4 5 void speak(){ 6 System.out.println("我是张三"); 7 } 8 9 public static void main(String[] args) { 10 Person person=new Person(); 11 person.speak

Java面向对象——方法与封装

封装 什么是封装: 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 如何实现封装: 修改属性的可见性,设为private. 建立共有的get/set方法,用于属性读写. 在get/set方法中加入属性的控制语句,对属性的合法值进行判断 便于使用者正确使用系统,防止错误修改属性 有助于系统之间的松耦合,提高系统独立性 提高软件的可重用性 降低了构建大型系统的风险 创建封装类 class Person { private String name

Java面向对象---方法递归调用

递归调用是一种特殊的调用形式,即方法自己调用自己 public int method(int num){ if(num==1){ return 1; } else { return num+method(num-1); } } 描述:main方法调用method(5),在method方法中参数不等于1,则再调用method(4),一直到参数等于1,则依次返回.在该例中,参数等于1时,将1返回给method(2),依次类推,当返回到method(5)时,再将从1加到5的和返回给main方法.

Java面向对象---方法的创建与重载

方法的创建 方法就是可重复调用的代码段. 定义: 访问修饰符 返回值类型 方法名(参数){ 方法主体 } 返回值类型:void(无返回值):基本数据类型:应用数据类型:类对象等. 方法名的命名规则:第一个字母小写,多个单词之间,后面单词的第一个字母大写.如userName. 参数:方法参数可以没有,可以是一个,也可以是多个.参数数据类型与返回值类型一样,可以是任意数据类型. 方法的重载 方法名相同,但是参数的类型或个数不同.通过传递的数据类型的不同或参数个数的不同来完成不同的功能.

Java面向对象----方法重载

方法重载(over load):方法名相同,参数列表不同,返回类型无关 package com.tanlei.newer; public class OverLoadDemo { public static void main(String[] args) { Printer printer=new Printer(1000); printer.print("hello"); printer.print(12); printer.print("hello", 12)

24. java面向对象 - 方法重写

一.方法的重写 1. 定义 ? 在子类中可以根据需要对从父类中继承来的方法进行改造,也称为方法的重置.覆盖.在程序执行时,子类的方法将覆盖父类的方法. 2. 要求 ? (1) 子类重写的方法必须和父类被重写的方法具有相同的方法名称.参数列表 ? (2) 子类重写的方法的返回值类型不能大于父类被重写的方法返回值类型 ? (3) 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限 子类不能重写父类中声明为private权限的方法 ? (4) 子类方法抛出的异常不能大于父类被重写方法的异常

JAVA面向对象 - 方法重载与覆盖

方法重载 方法重载就是在类的同种实现方式,到底采用哪种方式,取决与调用者给出的参数.方法重载特点是方法名相同,方法的参数类型,个数,顺序至少有一项不同,方法放回类型可以不同,方法的修饰符可以不同,只是放回类型不一样,不能构成重载 实例 1 package com.beekc.www; 2 3 public class Beekc { 4 public static void main(String[] args) { 5 Max c = new Max(); 6 System.out.print