java学习笔记3

1.方法

定义:用功能代码块{}将核心功能包起来,并且取一个名字.
调用方式:
      方法名(实际参数);
      单独调用:没有输出.
      输出调用:直接输出结果.
      赋值调用:返回值类型 变量名=方法名(实际参数);
注意事项:
      不能嵌套方法;
      形式参数类型必须携带,不可以省略;
      方法调用时,实际参数类型不需要携带;
格式:(1)有具体返回值类型的方法定义
     public static 返回值类型 方法名(形式参数类型 变量名){
          return 结果;
     }

  举例: 求2个数的和:

 package com.jhq;
import java.util.Scanner;
public class Sum {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数:");
        int a=sc.nextInt();
        System.out.println("请输入第二个数:");
        int b=sc.nextInt();
        int x=twoSum(a,b);
        System.out.println("两个数的和为:"+x);
    }
    public static int twoSum(int a, int b){
        int c=a+b;
        return c;
    }
}

 (2)没有具体返回值类型的;
     定义格式:  public static void 方法名(形式参数列表){
            直接输出数据
     }
     一般采用单独调用.

方法重载:多个方法名相同,参数列表不同(参数个数,参数类型,参数顺序),与返回值无关.
       目的:为了让这个功能的扩展性更多.

 举例:输出99乘法表;

package com.jhq;
import java.util.Scanner;
public class ChengFa {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入数据:");
        int a=sc.nextInt();
        table(a);
    }
    public static void table(int i){
        for(int x=1;x<=i;x++){
            for(int y=1;y<=x;y++){
                System.out.print(y+"*"+x+"="+(y*x)+"\t");
            }
            System.out.println();
        }
    }
}

2.数组

定义:是只能够存储同一种类型的容器,在同一数组中,元素的数据类型必须一致.
格式:数据类型[] 数组名称;    数据类型 数组名称[];
初始化:(1)动态初始化:   
         数据类型[] 数组名称=new 数据类型[长度];
       访问数组中的元素:
       数组名称[索引值] 索引值从0开始;

  举例: 访问数组  int[] arr=new int[3];中的每一个元素.

 package com.jhq;

public class Arry {
    public static void main(String[] args){
        int[] arr=new int[3];
        arr1(arr);
    }
    public static void arr1(int[] arr){
        arr[0]=1;
        arr[1]=6;
        arr[2]=5;
        System.out.println("数组的第一个元素为:"+arr[0]);
        System.out.println("数组的第二个元素为:"+arr[1]);
        System.out.println("数组的第三个元素为:"+arr[2]);
    }
}

多个数组对象的内存图解;

package com.jhq;
public class Arry1 {
    public static void main(String[] args) {
        int[] arr=new int[2];
        int[] arr1=new int[3];
        arr[0]=1;
        arr[1]=3;
        arr1[0]=5;
        arr1[1]=2;
        arr1[2]=4;
        System.out.println(arr);
        System.out.println(arr1);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        int[] arr2=arr;
        arr2[0]=5;
        arr2[1]=4;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
    }
}

 数组中的异常;
   (1)编译时期的异常:jvm检查语法不通过语法格式存在问题
   (2)运行时期异常:开发者:代码书写不严谨导致的问题.
       java.lang.ArrayIndexOutOfBoundsException:数组角标越界异常
        出现的原因:访问了数组中不存在的角标(索引值)
        如何解决:检查代码,更改索引值
        java.lang.NullPointerException:空指针异常
        引用类型的默认值都是null;
        String s = null ;  字符串是一种特殊的引用类型
        出现的原因:某一个对象已经为空了,null(没有堆内存地址),这个时候还要去访问元      素或者调用
        这个对象的方法,那么就出现空指针;
        如何解决:
            使用逻辑判断语句,对该对象进行非空判断.

 数组的应用:
     (1)数组的遍历:
  举例:遍历这个数组 int [] arr={25,30,2,85,62}

package com.jhq;
public class MaoPao {
    public static void main(String[] args){
        int[] arr={25,30,2,85,62,};
        System.out.println("数组为:");
        arrPrry(arr); 
          }
  public static void maoPao(int[] arr){
        for(int x=0;x<arr.length-1;x++){
            for(int y=0;y<arr.length-x-1;y++){
                if(arr[y]>arr[y+1]){
                    int temp=arr[y];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }
            }
        }
    }
}

 (2)求最大值或者最小值
   举例:

 package com.jhq;

public class ArryMax {
    public static void main(String[] args) {
        int[] arr={25,30,45,60,2};
        int max=getMax(arr);
        System.out.println("最大值为: "+max);
    }

    public static int getMax(int[] arr) {
        int max=arr[0];
        for(int x=0;x<arr.length;x++){
            if(max<arr[x]){
                max=arr[x];
            }
        }
        return max;
    }
}

 (3)数组逆序
 举例: 将数组int[] arr={1,25,30,52,20}逆序;

 package com.jhq;

public class ArryNi {
    public static void main(String[] args) {
        int[] arr={1,25,30,52,20};
        System.out.println("逆序前:");
        arrPrry(arr);
        System.out.println("逆序后:");
        arrNi1(arr);
        arrPrry(arr);
    }
    public static void arrPrry(int[] arr){
        System.out.print("[");
        for(int x=0;x<arr.length;x++){
            if(arr[x]==arr[arr.length-1]){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+",");
            }
        }
    }
    public static void  arrNi1(int[] arr){
        //定义两个变量
        //start:起始索引:0开始
        //end:最终索引:arr.length-1
        for(int start = 0,end = arr.length-1; start < end; start++,end--){
            //定义中间变量
            //元素互换
            int temp = arr[start] ;
            arr[start] = arr[end] ;
            arr[end] = temp ;
        }
    }
}

 (4)数组元素查询
举例 查询10第一次出现在数组int[] arr={10,20,60,50,40};中的索引值.

package com.jhq;
public class ChaXun {
    public static void main(String[] args) {
        int[] arr={10,20,60,50,40};
        int x=cha(arr,10);
        System.out.println("第一次出现的索引值为 :"+x);
    }
    public static int cha(int[] arr,int target){
        int index=-1;
        for(int x=0;x<arr.length;x++){
            if(target==arr[x]){
                index=x;
                break;
            }
        }
         return index;
    }
}

3.冒泡排序

      思想:两两相比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处,依次继续进行比较,即可得到排好序的数组.

图解如下:

    举例: int[] arr={25,30,2,85,62,};

package com.jhq;
public class MaoPao {
    public static void main(String[] args){
        int[] arr={25,30,2,85,62,};
        System.out.println("排序前:");
        arrPrry(arr);
        System.out.println("排序后:");
        maoPao(arr);
        arrPrry(arr);
    }
    public static void arrPrry(int[] arr){
        System.out.print("[");
        for(int x=0;x<arr.length;x++){
            if(arr[x]==arr[arr.length-1]){
                System.out.println(arr[x]+"]");
            }else{
                System.out.print(arr[x]+",");
            }
        }
    }
    public static void maoPao(int[] arr){
        for(int x=0;x<arr.length-1;x++){
            for(int y=0;y<arr.length-x-1;y++){
                if(arr[y]>arr[y+1]){
                    int temp=arr[y];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }
            }
        }
    }
}

4.面向对象

思想特点:
          1)更符合我们生活中思想行为习惯
           2)让更复杂的事情简单化
        3)角色发生了变化:我们从执行者变成了指挥者!
举例:
        买笔记本:
           面向过程:
               了解自己的需要配置--->西安赛格电脑城----->看一看--->砍价-----> 被坑了..
           面向对象:
            了解自己的需要配置---->找一个懂行的朋友----->买回来
设计原则:
     不断的创建对象,使用对象,指挥对象.
特征:封装,继承,多态.

5.类

定义:描述一组事物的属性和行为的集合.是java中最基本的单元.
包含:成员变量 在类中,方法外.
    成员方法 格式  public 返回类型 方法名(形式参数列表){
          业务体
    }
面试题:
  基本数据类型作为"形式参数"传递特点:形式参数的改变不会影响实际参数.
  引用类型作为"形式参数"的传递特点:形式参数的改变会影响实际参数.(string除外). 

6.对象

定义;描述一个具体的事物.  在测试类中使用:main方法所在类
代码体现:
   格式: 类名 对象名=new 类名();
   给具体的事物属性赋值
   对象名.成员变量=赋值;
   调用具体事物的行为
   对象名.成员方法名();

举例: 一个手机类
          品牌,价格,颜色.
          打电话,打游戏.
          品牌华为,价格7500,颜色土豪金.

package com.jhq;

public class PhoneTest1 {
    public static void main(String[] args) {
        Phone1 p1=new Phone1("华为",7500,"土豪金");
        p1.call("张三");
        p1.play();
        System.out.println("我的手机是:"+p1.getName()+",花了"+p1.getPrice()+",是"+p1.getColor());
        p1.setName("苹果13");
        p1.setPrice(13000);
        p1.setColor("绿色");
        System.out.println("我的手机是:"+p1.getName()+",花了"+p1.getPrice()+",是"+p1.getColor());
        p1.call("张三");
        p1.play();
    }
}
class Phone1{
    private String name;
    private int price;
    private String color;

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public Phone1(){}
    public Phone1(String name,int price,String color){
        this.name=name;
        this.price=price;
        this.color=color;
    }
    public void call(String callName){
        System.out.println("手机可以用来给"+callName+"打电话");
    }
    public void play(){
        System.out.println("手机正在打王者荣耀");
    }
}

 面试题:局部变量和成员变量的区别:
  (1)在类中的书写位置不同:
       局部变量:在方法中定义或在方法声明上;
       成员变量:在类中,方法外;
  (2)在内存中的位置不同:
       局部变量:在栈内存中
       成员变量:在堆内存中
  (3)生命周期不同:
       局部变量:随着方法的调用而存在,随着方法的调用结束而消失;
       成员变量:随着对象的创建而存在,随着对象的调用结束完毕,等待垃圾回收器空闲回收不会立即消失.
  (4)初始化时机不同:
       局部变量:要么先定义,使用之前必须初始化,要么直接初始化.
       成员变量:可以不赋值,系统默认堆成员变量初始化;
               也可以通过对象名.成员变量=赋值;
匿名对象:没有名字的对象.
      创建对象格式:
      类名 对象名=new类名();
      创建匿名对象的格式:
      new 类名();
      好处:   节省空间;
              开发中,匿名对象一般使用"一次即可",使用完毕就立即垃圾回收器回收;
              手机移动端/Android/鸿蒙系统:基于java语言
       访问类的成员变量:
       new 类名().成员变量名;
       访问类的成员方法:没有具体返回值类型
       new 类名().成员方法名();

6.1封装

private:私有的,不能直接访问的:
   特点:
        被priva修饰对的成员变量或者成员方法,只能在本类中被访问;
        外界类是不能直接访问的,间接可以通过公共的成员方法访问.
 局部变量名和成员变量名称一致(局部变量隐藏了成员变量),java提供了一个关键字this.
    this:代表当前类对象的地址引用.

图解:

 

7.构造方法

定义: 构造方法是一种特殊的方法,方法名和类名一致;
特点:
    (1)方法名和类名一致
    (2)构造方法没有返回值类型.
    (3)连void都没有.
 分类: 无参构造方法:没有参数;
       有参构造方法:有具体的参数类型;
作用:
       就是对类中的数据(成员属性)进行初始化;
注意事项:
        1)当我们开发者既没有提供无参构造方法,也没有提供有参构造方法,
           系统永远给我们提供 "无参构造方法"
            类名 对象名 = new 类名() ;
        2)如果我们提供了有参构造方法,那么系统不会在提供无参构造方法
            构造方法的作用:给类的成员属性可以进行数据初始化.