1.方法
方法的定义,调用 形参 实参 返回值类型 void return 可变参数 递归 重载
package com.text1;
public class TextA1 {
public static void main(String[] args) {
System.out.println(sum(1,2,3,5,4,6,8,9));
int num=jiecheng(5);
System.out.println(num);
}
//方法 函数 过程
//语法
/*
返回值类型 方法名(要见名知意) (参数列表) {
方法体
};
*/
//返回值类型 该方法必须返回一个这个类型的对象
//当一个方法不需要返回值 返回值类型就定义为void
//void中不能return null
//void可以return但是不能接其他的
public static int max(int a,int b){
//return 返回数据
int max=a>b?a:b;
return max;
}
//定义一个sum方法,接收两个int 返回和
public static int sum(int a,int b){
return a+b;
}
public static void printMax(int a,int b){
System.out.println(a>b?a:b);
return;//终止方法的作用
}
public static void printMaxA(int a,int b){
//得到最大值
//调用本类中已经定义好的方法
int result=max(a,b);
//打印
System.out.println(result);
}
//形参 定义方法时,参数列表的参数名 printMax中的ab
//实参 调用方法时实际传入的参数 如printMax中调用max中的ab
//重载
//在一个类中,方法名相同,参数列表不同为重载
//参数列表要素 1.参数类型不同 2.参数个数不同 3.参数顺序不同(是参数不同类型时的前后顺序,与形参名无关)
//定义一个方法,返回一个数组的最大值
public static int arr_max(int[] a){
int max=a[0];
for (int i=0;i<a.length;i++){
if (a[i]>max){
max=a[i];
}
}
return max;
}
//可变参数 声明参数后跟... 将可变参数当数组使用
//注意:
// 1.一个方法中最多只能有一个可变参数
// 2.可变参数必须放在参数列表的最后一个 (double a,int b,int... c)可以但是(double a,int... c,int b)不可以
// 3.数量可变类型不可变
// 4.调用可变参数方法可以使用数组代替
// 5.可变参数可以不传
public static int sum(int... a){
int sum=0;
for(int item:a){
sum+=item;
}
return sum;
}
//递归
//阶乘
public static int jiecheng(int num){
if (num==1){
return 1;
}
return num*jiecheng(num-1);
}
}
2.冒泡排序
(外加1.方法中的在其他类中调用方法)
package com.text1;
import java.util.Arrays;
public class TextB1 {
public static void main(String[] args) {
//在其他类中调用TextA1类的方法
//写明方法名和参数
TextA1.printMax(12,34);
int[] arr={45,31,88,71,43};
maopaopaixu(arr);
System.out.println(Arrays.toString(arr));
}
//冒泡排序
public static void maopaopaixu(int[] arr){
for (int j = 0; j <arr.length-1 ; j++) {
//比较一趟 最大值到数组最后
for (int i = 0; i <arr.length-1-j ; i++) {
//前后两个相邻的元素比较
//如果前面的元素大,就交换位置
//要考虑数组越界问题,arr.length-1
//内部-1-j避免重复冗余
if (arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}
}
}
3.类
类的定义 属性 方法 实例化对象 调用属性和方法 构造方法 默认构造方法
以staff为例:
package com.text1;
import java.math.BigDecimal;
public class Staff {
//在类中定义属性
//也叫全局变量
String code;
String sex;
String name;
double salary;
//类中的方法可以直接调用本类中的属性
public void work(){
System.out.println(name+"正在工作");
}
//定义构造方法(重载)
//1.没有返回值类型
//2.方法名与类名一样
//3.如果一个类没有定义任何一个构造方法,系统会给予一个默认的空的构造方法
//4.类中一旦自定义了任意的构造方法,系统默认的构造方法就消失了
Staff(){
}
//通过构造方法设置属性
Staff(String name,String sex,String code ,double salary){
//将参数name设置给name属性
//就近原则 还是方法内的name
//局部变量:在方法体或者代码块中声明的变量
//全局变量:在类中定义的变量
//在局部变量和全局变量重名的情况下,可以使用this关键字标注全局变量
this.name=name;
this.sex=sex;
this.code=code;
this.salary=salary;
}
}
package com.text1;
public class TextStaff {
public static void main(String[] args) {
//实例化对象 开辟内存空间
Staff staff = new Staff();
//设置对象的属性 类中声明了哪些属性,对象中就有哪些属性
staff.code="YG001";
staff.name="张三";
staff.sex="男";
staff.salary=10000;
Staff staffA = new Staff();
staffA.code="YG002";
staffA.name="李四";
staffA.sex="女";
staffA.salary=12000;
//调用对象的方法
staff.work();
staffA.work();
}
}
4.三大特性
封装 继承 多态
访问权限修饰符 extends 单继承 方法重写 this super 子父类间构造方法调用
向上转型
package com.text1;
public class TextD1 {
//继承 一个类继承父类,子类具有父类中定义好的属性和方法
//不是所有的属性和方法都能调用到 public,protected 本包下的父类default可以
//1.实现代码重用
//2.多态实现的基础
//注意:一个子类只能继承一个直接父类,java支持多重继承
//向上转型
public static void main(String[] args) {
BigPlane bp=new BigPlane("1212","red");
bp.code="1111";
bp.fly();
//调用方法看对象,调用属性看变量的声明
Plane p=new BigPlane("1511","yellow");//向上转型,看p后面是哪个类,就执行哪个类的方法
p.fly();//调用子类的方法
}
}
class Plane{
public Plane(String code,String color){
this.code=code;
this.color=color;
}
protected String code;//protected 子类 本包下可以访问到
String color;
public void fly(){
System.out.println("飞机起飞");
}
}
class BigPlane extends Plane {
//子类继承父类
//子类对父类中继承过来的方法重新定义----重写
//属性不能重写
//可以使用@override注解,来验证方法是否是重新的方法
//注意:返回值,方法名,参数列表不能发生变化
//重新的方法的访问权限只能更开放,不能更闭塞
@Override
public void fly(){//只能重写方法体,这一行不变
System.out.println("大飞机起飞");
}
//子父类之间的构造方法
public BigPlane(String code,String color){
//子类的构造方法中,首行必须调用父类的构造方法,默认调用父类的无参构造方法
//如果父类中没有无参构造方法,子类构造方法中必须明文声明调用父类哪一个构造方法
//使用super关键字调用父类的构造方法
super(code,color);
}
}
静态多态
动态多态
package com.text1;
public class TextE1 {
public static void main(String[] args) {
int num=1;
Parent p=getObj(num);//p这个变量可能指向任意一个子类的对象
p.method();//多态调用方法时可能会出现多种结果
//多态分类:
//静态多态:重载造成,在类编译时就可以确定调用的时哪一个方法
//动态多态:重写造成,只有在执行到该行代码,才能确定执行的是哪个类的方法
}
public static Parent getObj(int a){
if (a==1){
return new SonA();
}else if (a==2){
return new SonB();
}else{
return new Parent();
}
}
}
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");
}
}