方法的定义:
返回值类型 方法名(参数列表){方法体}
返回值类型:该方法必须返回一个这个类型对象
例:
static void sort(int[] arr){
for(int i=0;i<arr.iength-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
return;
}
上面就是一个实现整数类型数组内元素排序的方法,返回值类型为void(无返回值),方法名为sort
使用void类型可以写return,但不能return任何值(也不能是null),此处的作用为终止方法(不写也可)
调用
sort(数组);
参数有: 实参 形参
定义方法时,参数列表的参数名是形参;
调用时,实际传入的参数就是实参;
可变参数
声明
sum(int... a){}
使用: 将可变参数当做数组使用
注意: 1.一个方法中只能有一个可变参数
2.可变参数必须在参数列表的最后一个
3.数量可变类型不可变
4.调用可变参数方法,可以使用数组代替
5.可变参数可以不传
递归
public static int factorial(int num) {
if (num==1){
return 1;
}
return num*jiecheng(num-1);
}
以上是使用递归实现的阶乘方法
重载
在同一个类中方法名相同,参数列表不同即为重载
参数列表要素
1.参数类型不一样
2.参数个数不一样
3.参数的顺序不同
例:
public static void printMax(int a, int b) {
System.out.println(a>b?a:b);
}
public static void printMax(double a, double b) {
System.out.println(a>b?a:b);
}
排序算法
static void sort1(int[] arr){//冒泡排序
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1 - i; j++) {
if (a[j+1] < a[j]) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
static void sort2(int[] arr){//选择排序
for (int i = 0; i < a.length - 1; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[i]) {
int t = a[j];
a[j] = a[i];
a[i] = t;
}
}
}
}
static void sort3(int[] arr) {//插入排序
for (int i = 1; i < arr.length; i++) {
int key = arr[i];
int j = i - 1;
//移动arr[0..i-1]中大于key的元素,
//比他们目前的位置领先一个位置
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
类的定义
//访问修饰符 关键字class 类名
public class ClassName{
// 类的成员变量,方法等
// 属性(全局变量)
private int num1;
public String num2;
// 方法
public void methodName() {
// 方法体
}
//构造方法
public ClassName() {
// 构造方法体
}
}
定义构造方法
1.没有返回值类型
2.方法名和类名一样
3.如果一个类没有定义任何的构造方法,系统会给与一个默认的空的构造方法
4.类中一旦自定义了任意构造方法,系统给定默认构造方法就消失了
import java.math.BigDecimal;
public class Staff {
String code;
String sex;
String name;
double salary;
//通过构造方法设置属性
Staff(String name){
//将参数name设置给name属性
//就近原则
//局部变量: 方法体或者代码块中声明的变量
//全局变量: 在类中定义的变量
//在局部变量和全局变量重名的情况下,可以使用this关键字,标注全局变量
this.name=name;
}
public void work(){
System.out.println(name+"正在工作");
}
}
public class TestStaff {
public static void main(String[] args) {
//实例化对象 开辟内存空间
Staff staff=new Staff();
//设置对象的属性 类中声明了那些属性,对象中就有哪些属性
staff.code="YG10001";
staff.name="张三";
staff.sex="男";
staff.salary=10000;
Staff staffA=new Staff();
staffA.code="YG10002";
staffA.name="李四";
staffA.sex="女";
staffA.salary=12000;
//调用对象的方法
staff.work();
staffA.work();
}
}
面相对象特征(特性) : 封装------------继承------------多态
封装: 隐藏细节,不能让类随意访问 通过四个访问权限修饰符达到封装的效果
访问修饰符: 可以使用访问修饰符来限制类、成员变量和方法的访问范围。常见的访问修饰符包括 public(公共的,可以被任何类访问)、private(私有的,只能在同一个类中访问)、protected(受保护的,同包内及子类可访问)、以及默认访问修饰符(default)(不写任何修饰符,同包内可访问)。
继承: 一个类继承父类,子类就具有父类中定义好属性和方法
不是所有的属性和方法都能访问到 public protected 本包下的父类default可以访问
1.代码重用
2.多态实现的基础
注意: 1.一个子类只能有一个直接父类 2.java支持多重继承
class Plane {
public Plane(String code) {
this.code = code;
}
public Plane(String code, String color) {
this.code = code;
this.color = color;
}
protected String code; /* protected 子类 本包下*/
String color;
protected void fly() {
System.out.println("看,天上有个大飞机");
}
}
class BigPlane extends Plane {
//子类继承父类
//子类对父类中继承过来的方法重新定义:方法重写
//可以使用@Override注解,验证方法是否是重写的方法
/*注意: 返回值,方法名,参数列表不能发生变化
重写的方法的访问权限只能更开放,不能更闭塞*/
@Override
public void fly() {
System.out.println("看,天上有个更大的飞机");
}
public String code;
//子父类间的构造方法
public BigPlane(String code) {
//子类的构造方法中首行必须要用父类的构造方法
//默认调用父类的无参构造方法
//父类中没有无参构造方法,子类构造方法中必须明文声明调用父类哪一个构造方法
//使用super关键字调用父类的构造方法
super(code);
}
public BigPlane(String code, String color) {
//super(code,color);
super(code);
}
}
多态:
public class EasyE {
public static Parent getObj(int a){
if (a==1){
return new SonA();
}else if(a==2){
return new SonB();
}else{
return new Parent();
}
}
public static void main(String[] args) {
int num=2;
Parent p=getObj(num);//p这个变量可能指向任意个子类的对象
p.method();//多态: 调用方法时可能会出现多种结果
//多态分类:
//静态多态:重载造成,在类编译(javac)时就可以确定调用的是哪一个方法
//动态多态:重写造成,只有在执行到该代码,才能确定执行的是哪个类中的方法
}
}
class Parent{
public void method(){
System.out.println("parent");
}
}
class SonA extends Parent{
public void method(){
System.out.println("SonA");
}
}
class SonB extends Parent{
public void method(){
System.out.println("SonB");
}
}
调用方法看对象,调用属性看声明;