0基础学JAVA！！！（第三天）
一，方法：
（1）方法的定义：
定义一个方法需要有返回值类型 方法的名称（方法的参数）{方法体}
返回值类型：当这个方法不需要返回值的时候返回值类型就用void，用void不是返回一个null值，是不返回值！！在用void的时候可以写return，但是不返回值，用作终止方法
返回值可以返回与返回值类型相同的数值，用return返回
在return语句的后面不能在写其他任何代码了
public statis void fangfa(String name){
System.out.println("我爱java")
}（2）方法的调用：
写方法名（参数列表）
public static void wode(String name){
fangfa("关二爷");
}2.形参和实参
1.形参
形参顾名思义就是形式参数，没有实际的数值，在创建方法时括号内的参数列表就是形参
例如：int a；
上述的a就是形参
2.实参
实参顾名思义就是实际参数，有实际的意义，在调用方法的时候，传入的参数就是实参
例如：
public static void main(String[] args) {
fangfa("关二爷");
}
这里面的关二爷就是实参
3.可变参数
可变参数 int...
使用 将可变参数作为数组使用
注意点：
1.一个方法只能有一个可变参数
2.可变参数必须在参数列表的最后一个
3.参数列表的可变参数是数量可变，类型不能变
4.调用可变参数方法，可以用数组代替
5.可变参数可以不传
public static int sum(int...a){
int sum=0;
for (int item:a){
sum+=item;
}
return sum;
}4.重载
重载就是在同一个类中，如果方法名相同，参数列表不同，就可以构成重载
参数列表不同有以下三种：
参数的类型不同
参数的个数不同
参数的顺序不同
前两种很好理解，第三种可以用一个示例
下面这种可以
public static void printMax(int a,byte b){}
public static void printMax(byte b,int a){}
下面这种不可以
public static void printMax(byte a,byte b){}
public static void printMax(byte b,byte a){}5.递归
在递归当中我们经常会学到！99，这是一个很经典的案例下面我们用示例演示一下
public static int jiecheng(int num){
if (num==1){
return 1;
}
return num*jiecheng(num-1);
}
public static void main(String[] args) {
int num=jiecheng(99);
System.out.println(num);
}6.排序
排序有选择排序，冒泡排序，快速排序，堆排序，希尔排序，插入排序，归并排序
1.选择排序：
public class Selectionsort {
int[] arr={10,54,23,47,1,23,4,35,455};
public static void main(String[] args) {
Selectionsort y=new Selectionsort();
y.SelectSort(y.arr);
System.out.println(Arrays.toString(y.arr));
}
//创建一个排序的方法所以创建对象的时候要调用Test5
public void SelectSort(int[] arr){
for (int i=0;i<arr.length;i++){
int index=i;
for (int j=i+1;j< arr.length;j++){
if(arr[index]>arr[j]){
int t=arr[index];
arr[index]=arr[j];
arr[j]=t;
}
}
}}2.快速排序：
public static void main(String[] args) {
int[] arr={10,54,23,47,1,239,4,35,455};
Quicksort t=new Quicksort();
quicksort(arr);
System.out.println(Arrays.toString(arr));
}
public static void quicksort(int[] arr){
quicksort(arr,0, arr.length-1);
}
public static void quicksort(int[] arr,int left,int right){
if (left>=right){
return;
}
int r=right;
int l=left;
int ji=arr[left];
while(l<r){
while(l<r&&arr[r]>=ji){
r--;
}
while(l<r&&arr[l]<=ji){
l++;
}
if (l!=r){
int t=arr[l];
arr[l]=arr[r];
arr[r]=t;
}
}
if (l!=left){
int t=arr[l];
arr[l]=arr[left];
arr[left]=t;
}
quicksort(arr,left,l-1);
quicksort(arr,r+1,right);
}
3.冒泡排序
public static void main(String[] args) {
int[] arr = {1, 54, 12, 5, 28, 185, 4, 21, 5254, 245, 1565, 42, 15, 504, 0};
for (int i=0;i< arr.length;i++){
for (int j=0;j<i;j++){
if (arr[i]<arr[j]){
int t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
System.out.println(Arrays.toString(arr));
7.类
1.类的定义：
修饰符+ 返回值类型 +类名（参数列表）{代码块}
一个类中只能有一个public类型的类
2.类的属性：
类型 +属性名
类的属性也叫全局变量（在整个类中都可以访问到的量）
局部变量：在代码块或者方法快中定义的变量
3.类的方法：
在类中可以调用类的方法
4.类的实例化
public class Staff {
Staff(String name,String sex,double salary,String code){
this.name=name;
this.salary=salary;
this.sex=sex;
this.code=code;}
String name;
String code;
String sex;
double salary;
//类中的方法可以直接调用类中的属性
public void work(){
System.out.println(name+"工作了");
}
}
public static void main(String[] args) {
//实例化对象 开辟内存空间
Staff s=new Staff();
//设置对象的属性 类中声明了哪些属性，对象中就有哪些属性
s.code="YG1001";
s.name="张三";
s.sex="男";
s.salary=10000;
Staff s1=new Staff();
s1.code="YG1002";
s1.name="李四";
s1.sex="男";
s1.salary=12000;
//调用对象的方法
s.work();
s1.work();
}8.构造函数
//定义构造方法（用作对属性初始化）
// 1.没有返回值类型（返回值类型不需要定义） 没有
//2.方法名和类名相同
//3.如果一个类没有定义任何的构造方法，系统会给一个默认的空的构造方法
//4.一个类中一旦自定义了任意的构造方法，系统给定的默认的构造方法就消失了
public class Staff {
Staff(){}
}
也可以用构造方法进行属性定义
Staff(String name,String sex,double salary,String code){
//将参数nmae设置给nama属性
//就近原则
//局部变量 在方法体或者代码块中声明的变量
//全局变量 在类中定义的变量
//在局部变量和全局变量重名的情况下，可以使用this关键字，标注全局变量
this.name=name;
this.salary=salary;
this.sex=sex;
this.code=code;
}this关键字：在局部变量和全局变量重名的情况下，可以使用this关键字对全局变量进行标注
9.三大特性：封装.继承.多态
封装：隐藏细节 （属性，方法） 不能让其他类随意访问
public protected default private这四个是访问权限修饰符
public表示在其他任何类中都可以访问到
protected表示只能在子类和本类中访问到（只能向下兼容）
default表示只能在本包下访问
private表示只能在本类下进行访问
getter和setter只是封装当中比较经典的操作，不能代替封装的定义
2.继承：extends
//一个类可以继承另一个类，子类可以继承父类，子类中具有父类中定义好属性和方法
//但不是所有的属性和方法可以访问到 public protected default
//好处：1.可以实现代码重用
// 2.实现多态的基础
//注意：一个类只能继承一个直接父类
// 2.java支持多重继承（父--子--孙）
在Java当中，Java是一个单继承语言
当父类中的方法不需要的时候我们就可以对继承到的方法进行重写
在重写的时候我们可以用@Override进行注解如果重写失败会报错
调用方法看对象（看new后边的） 调用属性看变量的声明（对象的前面） 注意：返回值，方法名，参数列表不能变化 重写的方法的访问权限只能更开放，不能更闭塞 子父类之间的构造方法
在继承父类的构造方法的时候如果父类的构造方法是有参的，那么会报错，这个时候就需要用到super（）
this（）
这两个方法
子类的构造方法中首行必须要用父类的构造方法 默认调用无参的构造方法 父类中没有无参构造方法，子类构造方法中必须明文指定调用父类哪一个构造方法 子类构造方法中必须首行使用super关键字调用父类的构造方法
3.多态
向上转型：我们如果已经有了一个Plane类，而且BigPlane类继承自Plane类，那么在创建对象的时候就可以：Plane p=new BigPlane
多态：调用方法时，可能会出现多种结果 多态分类： 静态多态：主要由重载造成的，在类编译时就可以确定调用的是哪一个方法 动态多态：主要由重写造成的，只有在执行到该行代码，才能确定执行的是那个类中的方法
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=1;
Parent p=getObj(num);//p这个变量可能指向任意一个子类的对象
p.method();
}
}
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");
}
}
标签：arr,JAVA,String,构造方法,int,void,基础,第三天,public From： https://blog.csdn.net/m0_73570063/article/details/140474565