一、Java方法
1.方法的定义
-
返回值类型 方法名（参数列表）{方法体}
1.1 返回值类型
-
返回值类型 该方法必须返回一个这个类型的返回值对象，return返回数据
public static int max(int a,int b) { //return返回数据 //方法名和方法名会排斥，方法名与类名不会，即可以同名 int max = a > b ? a : b; System.out.println(); return max; } -
当一个方法不需要返回值，返回值类型就定义为void
-
void中不能return null，但是void的方法可以写return； return：执行到此就结束，其下代码不可达,会报错 ” return ；“ 代表终止代码 void类中可以写“return ；”不能写 return null
//当一个方法不需要返回值，返回值类型就定义为void /*!!!!void中不能return null， 但是void的方法可以写return； return：执行到此就结束，其下代码不可达,会报错 ” return ；“ 代表终止代码 void类中可以写“return ；”不能写 return null*/ public static void printMax(int a,int b){ System.out.println(a>b?a:b); return ;//代表终止代码 //System.out.println();//return：执行到此就结束，其下代码不可达,会报错 }1.2形参与实参
-
形参：定义方法时，参数列表的参数名 实参：调用方法时，实际传入的参数
public static void printMaxA(int a,int b){//此是a是形参 //在本类调用本类class中已经定义的方法 int max = max(a, b);//此时a是实参 System.out.println(max); }重载：在一个类中（前提），方法名相同，参数列表不同，即为重载 参数列表要素：1.参数类型不同 2.参数的个数不同 3.参数的顺序不同（与返回类型无关)
public static void printMax(byte a,byte b){ } /*与返回类型无关--报错 public static byte printMax(byte a,byte b){ }*/ //类型不同 public static void printMax(int a,byte b){ } //参数列表顺序不同 public static void printMax(byte a,int b){ } //参数的个数不同 public static void printMax(byte a,byte b,byte c){ }1.3可变参数
-
声明-- int...a；
-
使用-- 将可变参数当做数组来使用
注意点：1.一个方法只能有一个可变参数 * 2，可变参数必须在参数列表最后一个 * 3.数量可变，元素类型不可变 * 4.调用可变参数的方法，可以使用数组来代替 * 5.可变参数也可以不传值
public static int sun(int... a){
int sum=0;
for(int item: a){
sum+=item;
}
return sum;
}
//至少传入2个参数
public static void sum(boolean b ,byte c,int... a){
System.out.println("0");
}1.4递归--阶乘
public static int jiecheng(int num){
if (num==1){
return 1;
}
return num*jiecheng(num-1);
}
public static void main(String[] args) {
System.out.println(jiecheng(3));
}二、排序方式
2.1冒泡排序
public static void main(String[] args) {
int []arr={98,12,4,5,78,9,32,5,-10};
Buble(arr);
System.out.println(Arrays.toString(arr));
}
//冒泡排序
public static void Buble(int[] arr){
for(int j=0;j<arr.length-1;j++){
//考虑数组越界问题
//完成一次，效果：最大的值放到最后
for(int i=0;i<arr.length-j-1;i++){
//前面的大，交换位置
if(arr[i]>arr[i+1]){
int t=arr[i];
arr[i]=arr[i+1];
arr[i+1]=t;
}
}
}
}三、面向对象
3.1对象
在Java中万物皆对象，先有对象再有类，有类就一定有对象
-
类：对这类对象行为和属性的描述 属性：又叫做全局变量，在整个类中都可以访问到的量、
-
定义构造方法： 1、没有返回值类型（void是没有返回值） 2、方法名和类名一样 3、如果一个类没有定义任何的构造法，系统会给一个默认的空的构造方法 4、类中一但定义了任意的构造方法，系统默认给定的构造方法就消失了
- !!! 时间用long ,金融用BigDecimal
-
Staff(){ } //通过构造方法设置属性 Staff(String name){ this.name=name; } Staff(String code,String sex,String name,BigDecimal salary){ this.sex=sex; this.code=code; this.name=name; this.salary=salary; } -
局部变量：在方法体或者代码块中声明的变量 全局变量：在类中定义的变量就是全局变量--属性 在局部变量和全局变量重名的情况下，可以使用this关键字，标注全局变量
-
运行此类中的主方法，这个类就是主类（可以有多个main---经测试，可以哦）
public class EasyC { //运行此类中的主方法，这个类就是主类（可以有多个main---经测试，可以哦） public static void main(String[] args) { //卡车类 ：品牌 颜色 时速 Car car = new Car(); car.brand="小米"; car.color="黑色"; car.v=100; car.say(); } } class Car{ public static void main(String[] args) { System.out.println("测试main"); } String brand; String color; int v; public void say(){ System.out.println("这辆卡车的牌子，颜色，时速依次为："+brand+color+v+"km/s"); } }3.2面向对象特征
- 封装：
1.隐藏类细节（属性与方法），不能让其他类随意访问
2.通过4个访问权限修饰符达到封装的效果： * public：公共的 （all） * protected:受保护的（家族性的） 其他包的子孙类以及本包下 * default:默认的（本包下） * private:私有的（本类下） * gettet setter封装 javabean（专门存储数据的封装）
- 继承
1.一个类继承父类，子类就具有父类中已经定义好的属性与方法 2.注意点：不是所有的属性与方法都可以访问到(可以访问到父类的非私有属性与方法)， public protected default->本包下的父类或子类 3.（方法）重写：子类对父类中继承过来的方法重新定义(方法可以重写，属性没有重写概念) 重写时只能重新定义方法体，返回值类型，方法名，参数列表不能发生变化 重写的方法的访问权限只能更开放，不能更闭塞 可以使用 @Override注解来验证方法是否是重写的方法，如果不是注解会报错 4.好处：1.代码重用 2.多态实现的基础 5.局限性：1.一个子类只能有一个直接父类 2.java支持多重继承 - 多态
- 静态多态：
在类编译时就可以确定调用的是哪一个方法（主要因为重载造成）
- 动态多态
当执行到此行代码才能确定执行的是哪一个类中的方法（主要由重写造成）
public static Parent getObject(int a){ if(a==1){ return new Son1(); }else if(a==2){ return new Son2(); }else{ return new Parent(); } } public static void main(String[] args) { int num=1; Parent p=getObject(num);//p可能执行任意一个子类的对象 p.method();//多态：调用方法时可能会出现多种结果 /*多态分类： 静态多态：在类编译时就可以确定调用的是哪一个方法（主要因为重载造成） 动态多态:当执行到此行代码才能确定执行的是哪一个类中的方法（主要由重写造成） */ } } class Parent{ public void method(){ System.out.println("parent"); } } class Son1 extends Parent{ public void method(){ System.out.println("son1"); } } class Son2 extends Parent{ public void method(){ System.out.println("son2"); } } -
子父类之间的构造方法： * 子类的构造方法中，首行必须调用父类的构造方法， * 默认调用父类的无参构造方法 * 如果父类中没有无参构造方法，子类构造方法必须明文声明调用父类哪一个构造方法 * 使用super关键字调用父类的构造方法（单继承）
-
如果子类中没有定义code，就会和父类共用一个code，就会出现this super值一样的情况
- 调用方法看对象，调用属性看变量声明----子类声明，值给子类；父类声明，给父类（属性看左边，方法看右边）
-
/*多态：*/ public static void main(String[] args) { BigPlane bigPlane = new BigPlane(); bigPlane.code="1002"; bigPlane.fly();//大飞机在飞 bigPlane.printCode();//super--null this--1002 //向上转型 Plane P = new BigPlane(); //如果子类中没有定义code，就会和父类共用一个code，就会出现this super值一样的情况 P.code="12"; P.printCode();//super--12 this--null P.fly();//大飞机在飞 //调用方法看对象 调用属性看变量声明--子类声明，值给子类；父类声明，给父类 } } class Plane{ public Plane(){} public Plane(String code){ //构造方法作用：对属性进行初始化，不是开辟空间（new开辟空间） this.code=code; } String code; String color; public void fly(){ System.out.println("飞机在飞"); } public void printCode(){ System.out.println("super:"+this.code); } } //子类继承父类 class BigPlane extends Plane{ public BigPlane(){} String code; public BigPlane(String code){ //System.out.println(); super(code);//报错，因为子类的构造方法中，首行必须调用父类的构造方法 } /* //报错：因为父类没有2个参数的构造方法，所以不能调用，就报错了呀 public BigPlane(String code,String color){ //System.out.println(); super(code,color);//报错，因为子类的构造方法中，首行必须调用父类的构造方法 }*/ @Override public void fly(){ System.out.println("大飞机在飞"); } public void printCode(){ System.out.println("super--"+super.code); System.out.println("this--"+this.code); }
扫一扫
796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
