java基础4

package com.edu_01;

/**

 * 1.2 有明确返回值的方法调用（画图讲解方法的调用流程，写一个加法运算演示各种调用区别）：

        A:单独调用

            没有意义

        B:输出调用

            不是特别好,因为我们可能需要对结果进行进一步的操作。

        C:赋值调用

            推荐方案

 *

 */

public classFunctionDemo2 {

    public static void main(String[] args) {

        //方法的调用一定是在main方法中被调用，因为main方法是一个程序的入口

        //A:单独调用，没有太大的意义

        //方法调用一定是传递的实际参数

        //add(10, 20);

       

        //B:输出调用

        //System.out.println(add(10, 20));

       

        //C:赋值调用,方便我们后面对这个变量的进一步操作

        //注意：方法的调用需要遵循：1.要啥类型的参数传递啥类型的参数

        //                 2.返回什么类型的值，就使用什么类型的变量接受

        int d =add(10, 20);

        System.out.println(d);

    }

   

    //方法与方法之间是平行关系，定义一个方法必须是在类中其他方法外

   

    /**

     * 需求：定义一个两个数求和的方法

     * 修饰符：public static

     * 返回值类型：int

     * 方法名：add

     * 参数列表：int a,int b

     * 方法体：{

     * intc = a+ b;

     * returnc;

     * }

     * 注意：定义一个方法一定要做到两个明确

     * 1.方法的参数类型和参数个数

     * 2.方法的返回值类型

     */

   

    public static int add(int a,int b){

        int c = a+ b;

        return c;

    }

   

}

package com.edu_01;

/**

 * 1.5 方法的注意事项（依然用定义的加法的方法进行演示）：

        A:方法不调用不执行

        B:方法与方法是平级关系，不能嵌套定义

        C:方法定义的时候参数之间用逗号隔开

        D:方法调用的时候不用在传递数据类型

        E:如果方法有明确的返回值，一定要有return带回一个值

 */

public classFunctionDemo3 {

    public static void main(String[] args) {

        System.out.println(add(10,20));

    }

   

    //写一个两个数相加的方法

    /**

     * 两个明确：

     * 参数列表：2，int

     * 返回值：有，int

     */

    public static int add(int a,int b){

        return a+b;

    }

   

 

}

package com.edu_01;

 

import java.util.Scanner;

 

public classFunctionDemo4 {

    public static void main(String[] args) {

        /**

         * 调用下面的求最大值的方法，数据来自键盘录入

         *

         */

        //创建键盘录入对象并导包

        Scannersc = newScanner(System.in);

       

        //获取键盘录入数据

        System.out.println("请输入第一个数据");

        int a = sc.nextInt();

        System.out.println("请输入第二个数据");

        int b = sc.nextInt();

       

        //调用求最大值的方法

        int max =getMax(a,b);

        System.out.println(max);

    }

    /**

     * 1.6 需求：写一个功能实现返回两个数的较大值。

          要求，数据来自于键盘录入。

     */

    /**

     * 两个明确：

     * 形式参数：2，int

     * 返回值：有，int

     */

    public static int getMax(int a,int b){

        int c = a>b?a:b;

        return c；

}      

}

package com.edu_01;

 

import java.util.Scanner;

 

public classFunctionDemo5 {

    public static void main(String[] args) {

        //创建键盘录入对象并导包

        Scannersc = newScanner(System.in);

        System.out.println("请输入第一个数据");

        int a = sc.nextInt();

        System.out.println("请输入第二个数据");

        int b = sc.nextInt();

       

        //调用方法进行判断

        System.out.println(isEquals(a,b));

       

    }

   

    /**

     * 写一个功能实现比较两个数据是否相等。

     * 两个明确：

     * 参数列表：2，int

     * 返回值：有，布尔类型

     */

    public static boolean isEquals(int a,int b){

//      booleanflag = a==b;

//      returnflag;

        return a==b;

    }

   

}

 

 

 

 

 

 

 

 

 

 

 

package com.edu_01;

/**

 * 1.8  需求1：请在控制台输出4行5列的星形。

        需求2：请在控制台输出6行7列的星形。

        需求3：请在控制台输出8行9列的星形。 

        （最终封装成方法进行调用）

 */

public classFunctionDemo6 {

    public static void main(String[] args) {

        //需求1：请在控制台输出4行5列的星形。

        /**

         * 这里是for循环的嵌套，

         * 外层for循环控制行，

         * 内层for循环控制列，

         * 外层走一次，内层走一轮

         * *****

         *  *****

         *  *****

         *  *****

         *

         */

        /*for (int i = 0; i < 4; i++) {

            for(intj = 0;j<5;j++){

                System.out.print("*");

            }

            //添加一个换行符

            System.out.println();

        }*/

       

       

        //需求2：请在控制台输出6行7列的星形。

        /*for (int i = 0; i < 6; i++) {

            for(int j = 0; j < 7; j++) {

                System.out.print("*");

            }

            System.out.println();

        }*/

       

       

        //需求3：请在控制台输出8行9列的星形。

        /*for (int i = 0; i < 8; i++) {

            for(int j = 0; j < 9; j++) {

                System.out.print("*");

            }

            System.out.println();

        }*/

       

        //printXing(10, 8);

        //printXing(5, 6);

    }

   

   

    /**

     * 封装打印成星星的方法

     * 分析：

     * 参数列表：2，int

     * 返回值：无

     */

 

    public static void printXing(int row,int col){

        for (int i = 0; i < row; i++){

            for (int j = 0; j < col; j++){

                System.out.print("*");

            }

            System.out.println();

        }

    }

   

   

}

package com.edu_01;

 

public classFunctionDemo7 {

    public static void main(String[] args) {

        System.out.println(getMax(10,5, 8));

    }

 

    /**

     * 作业：需求：键盘录入三个数据，返回三个数中的最大值

     * 分析：

     * 参数列表：3，int

     * 返回值：有，int

     */

    public static int getMax(int a,int b,int c){

        int max ;

        if (a>b) {

            //a大

            if (a>c) {

                //a最大

                max= a;

            }else {

                //c最大

                max= c;

            }

        }else {

            //b大

            if (b>c) {

                //b

                max= b;

            }else {

                //c

                max= c;

            }

        }

        return max;

       

    }

    package com.edu_02;

/**

 * 方法重载：

            前提：在同一个类中，

            允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

 *

 */

public classFunctionOverload {

    public static void main(String[] args) {

        //调用下面的两个参数的加法

        System.out.println(add(10,20));

       

        ///调用下面的三个参数的加法

        System.out.println(add(10,20, 30));

        /**

         * 注意：jvm虚拟机会根据方法被调用的参数个数及参数类型自动匹配

         * 符合条件和规则的方法

         */

    }

    /**

     * 2.1   需求1：求两个数据和

            需求2：求三个数据和

            需求3：求四个数据和

     */

   

    //需求1：求两个数据和

    public static int add(int a,int b){

        System.out.println("两个参数的被调用");

        return a+b;

    }

   

    //需求2：求三个数据和

    public static int add(int a,int b,int c){

        System.out.println("三个参数的被调用");

        return a+b+c;

    }

   

    //需求3：求四个数据和

    public static String add(Stringa,String b){

        System.out.println("四个参数的被调用");

        return a+b;

    }

}

 

   

}

package com.edu_02;

 

public classFunctionOverload2 {

    public static void main(String[] args) {

        //定义两个byte类型的数据，进行比较

        int a = 10;

        int b = 20;

        System.out.println(isEquals(a,b));

       

    }

 

    /**

     * 比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，

     * 两个int类型，两个long类型，并在main方法中进行测试

     */

    public static boolean isEquals(byte a,byte b){

        System.out.println("比较两个byte类型的数据是否相等");

        return a==b;

    }

   

    public static boolean isEquals(short a,short b){

        System.out.println("比较两个short类型的数据是否相等");

        return a==b;

    }

   

   

    public static boolean isEquals(int a,int b){

        System.out.println("比较两个int类型的数据是否相等");

        return a==b;

    }

   

    public static boolean isEquals(long a,long b){

        System.out.println("比较两个long类型的数据是否相等");

        return a==b;

    }

   

   

}

package com.edu_03;

/**

 * 3.2

    数组的定义格式

        A:数据类型[]数组名;--推荐使用这种

            int[]arr;

            char[]chs;

            boolean[]boos;

        B:数据类型数组名[];

            intarr[];

 

        区别：念法上区别

            int[]arr;

                int类型的数组，arr

            intarr[];

                int类型的，arr[]

 */

public classArrayDemo {

    public static void main(String[] args) {

       

    }

 

}

package com.edu_03;

/**

 * 3.4

    如何为数组进行初始化呢?

        A:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

 *3.5

    动态初始化：

        初始化时只指定数组长度，由系统为数组分配初始值。

        格式：

            数据类型[]数组名 = new 数据类型[数组长度];

            数组长度其实就是数组中元素的个数。

 */

public classArrayDemo2 {

    public static void main(String[] args) {

        //创建一个int类型的数组，这个数组的长度为3

        //动态的初始化了一个数组

        int[] arr =new int[3];

        System.out.println(arr);//[I@33abb81e,这是一个地址值

        System.out.println(arr[0]);//0

        System.out.println(arr[1]);//0

        System.out.println(arr[2]);//0

       

        //再给每一个元素进行赋值

        arr[0]= 10;

        arr[1]= 20;

        arr[2]= 30;

        System.out.println(arr);//[I@33abb81e,这是一个地址值

        System.out.println(arr[0]);//10

        System.out.println(arr[1]);//20

        System.out.println(arr[2]);//30

       

       

    }

 

}

package com.edu_03;

 

public classArrayDemo3 {

    public static void main(String[] args) {

        /**

         * 3.9（简单画内存图）定义两个数组，分别输出数组名及元素。

         *      然后分别给数组中的元素赋值，分别再次输出数组名及元素。

         */

        int[] arr =new int[3];

        System.out.println(arr);//[I@33abb81e

        System.out.println(arr[0]);//0

        System.out.println(arr[1]);//0

        System.out.println(arr[2]);//0

       

        System.out.println("-----------");

        arr[1]= 30;

        arr[2]= 40;

        System.out.println(arr);//地址值

        System.out.println(arr[0]);//0

        System.out.println(arr[1]);//30

        System.out.println(arr[2]);//40

       

       

    }

 

}

package com.edu_03;

 

public classArrayDemo4 {

    public static void main(String[] args) {

        /**

         * 3.10

            定义两个数组，先定义一个数组，赋值，输出。

            然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。

            然后给第二个数组赋值，再次输出两个数组的名及元素。

         */

        int[] arr =new int[3];

        arr[0]= 10;

        arr[1]= 20;

        arr[2]= 30;

       

        //输出数组中的元素

        System.out.println(arr[0]);//10

        System.out.println(arr[1]);//20

        System.out.println(arr[2]);//30

       

        System.out.println("-----------------");

        int[] arr2 = arr;

        arr2[1]= 300;

        arr2[2]= 200;

       

        System.out.println(arr[1]);//300

        System.out.println(arr[2]);//200

       

    }

 

}

package com.edu_03;

 

public classArrayDemo5 {

    public static void main(String[] args) {

        /**

         * B:静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

         *

         * 3.11

            静态初始化：

                初始化时指定每个数组元素的初始值，由系统决定数组长度。

       

                格式：

                    数据类型[]数组名 = new 数据类型[]{元素1,元素2,…};

       

                简化格式：

                    数据类型[]数组名 = {元素1,元素2,…};

         *

         */

        //使用静态初始化一个int数组（标准格式）

/*      int[]arr = new int[]{1,3,5,6};

        System.out.println(arr);//[I@33abb81e

        System.out.println(arr[0]);//1

        System.out.println(arr[1]);//3

        System.out.println(arr[2]);//5

        System.out.println(arr[3]);//6

*/     

        System.out.println("------------------");

        //使用静态初始化一个数组(简化格式)

        int[] arr2 = {10,30,20};

        System.out.println(arr2);//[I@7f39ebdb

        System.out.println(arr2[0]);//10

        System.out.println(arr2[1]);//30

        System.out.println(arr2[2]);//20

       

    }

 

}

package com.edu_03;

/**

 * 3.12（写一个案例进行演示）

    数组操作常见的两个小问题

        A:

            ArrayIndexOutOfBoundsException:数组索引越界异常

            怎么产生的：

                你访问了不存在的索引。

            如何解决：

                修改你的访问索引。

        B:

            NullPointerException:空指针异常

            怎么产生的：

                引用已经不再指向堆内存

            如何解决：

                一般来说，只要是引用类型的变量，我们在使用前，都要先判断是否为null。

                如果不为null，才继续使用。

 */

public classArrayDemo6 {

    public static void main(String[] args) {

        //静态初始化一个数组，使用简化格式

        int[] arr = {1,3,5,6};

        //取出数组中的每一个元素

        System.out.println(arr[0]);

        System.out.println(arr[1]);

        System.out.println(arr[2]);

        System.out.println(arr[3]);

        //System.out.println(arr[4]);

        /**

         * java.lang.ArrayIndexOutOfBoundsException:数组索引越界异常

         * ，不能访问超过数组最大索引的元素，如果访问就会报出这个数组索引越界异常

         */

       

        //arr = null;

        /**

         * java.lang.NullPointerException:空指针异常，说白了此刻我的引用

         * 毫无指向

         */

        System.out.println(arr[1]);

       

    }

 

}

package com.edu_03;

/**

 * 3.13       

    数组遍历:

        依次输出数组中的每一个元素

 

    数组遍历标准格式：

        for(intx=0; x<数组名.length; x++) {

            System.out.println(数组名[x]);

        }

 

    练习：

        自己定义一个数组，并遍历。

 *

 */

public classArrayDemo7 {

    public static void main(String[] args) {

        //定义一个数组

        int[] arr = {1,3,5,6};

       

        //遍历

//      System.out.println(arr[0]);

//      System.out.println(arr[1]);

//      System.out.println(arr[2]);

//      System.out.println(arr[3]);

       

        //使用for循环改进数组遍历的方法

        //数组的长度，怎么获取,通过数组的length属性获取数组的长度

        //System.out.println(arr.length);

        for(int i=0;i<arr.length;i++){

            System.out.print(arr[i]+"  ");

        }

    }

 

}

package com.edu_03;

 

public classArrayDemo8 {

    public static void main(String[] args) {

        //定义一个数组

        int[] arr = {5,6,7,8};

        printArray(arr);

    }

 

    /**

        3.14

        我们可能有很多个数组需要遍历，所以我们把遍历写成一个功能。

     */

    /**

     * 分析：

     * 参数列表：1，int[]

     * 返回值：无

     */

    public static void printArray(int[] arr){

        //拿到arr作何操作？？？

        for (int i= 0;i<arr.length;i++) {

            //打印数组中的每一个元素

            System.out.print(arr[i]+",");

        }

    }

 

}

package com.edu_03;

 

public classArrayDemo9 {

    public static void main(String[] args) {

        /**

         * 3.15

            数组获取最值(获取数组中的最大值最小值)  

         */

        int[] arr = {5,7,9,10};

       

        //假设数组中的第一个元素就是最大值

        int max = arr[0];

       

        //for循环遍历数组，在for循环中进行比较判断

        for (int i = 0; i < arr.length; i++) {

            if (arr[i]>max) {

                max= arr[i];

            }

        }

       

        System.out.println(max);

    }

 

}

package com.edu_04;

 

public classCar {

   

    //成员变量，位于类中方法外

    /**

     * 品牌，价格

     */

    Stringbrand;

    int price;

   

    //成员方法，没有static,方法与方法之间是平性关系

    /**

     * 拉货，拉人

     */

    public void laHuo(){

        System.out.println("汽车可以拉货");  

    }

   

    public void laRen(){

        System.out.println("汽车可以拉人");

    }

   

}

package com.edu_04;

/**

 * 得到手机这个事物：

 *     属性：品牌，价格，颜色

 *      行为：打电话，玩游戏，发短信

 *

 * 将手机事物转换成手机类：

 *      成员变量：品牌，价格，颜色

 *      成员方法：打电话，发短信，玩游戏

 *

 */

public classPhone {

    //成员变量

    Stringbrand;

    int price;

    Stringcolor;

   

    //成员方法

    public void call(){

        System.out.println("手机可以打电话");

    }

   

    public void sendMessage(){

        System.out.println("手机还可以发短信");

    }

   

    public void playGame(){

        System.out.println("手机还可以耍游戏");

    }

 

}

package com.edu_04;

 

public classStudent {

    /**

     * 学生事物：

     *      属性：姓名，年龄

     *      行为：学习，睡觉

     *

     *

     * 转化为学生类：一个类是由成员变量和成员方法组成

     * 学生类：

     *      成员变量(属性)：姓名，年龄

     *              -- 位置在类中方法外定义的变量就叫成员变量，这个变量一般来说

     *                  是用于描述这个类的

     *      成员方法（行为）：学习，睡觉

     *

     */

   

    //定义学生的成员变量

    Stringname;

    int age;

   

    //定义成员方法

    public void eat(){

        //局部变量：位于方法中或者方法上的变量叫局部变量

        System.out.println("肚子饿了需要就餐");

    }

   

    public void sleep(){

        System.out.println("学习困了该睡觉");

    }

 

}

package com.edu_05;

 

public classStudent {

   

    //学生的成员变量

    Stringname;

    int age;

   

    //成员方法

    public void eat(){

        System.out.println("学生爱吃米饭");

    }

   

    public void study(){

        System.out.println("吃饱了该学习了");

    }

   

    public void makePlane(){

        System.out.println("学生会制造飞机模型");

    }

 

}

package com.edu_05;

/**

 * 7.1 一个文件一个类

        类的使用（拿学生类过来练习，并画内存图进行讲解）

        使用一个类，其实是使用该类的成员。(变量和方法)

 

        我们要想想用一个类的成员，就必须创建该类的对象。

        如何创建类的对象呢?

            格式：

                类名对象名 = new类名();

 

                就表示创建了该类类型的一个对象。

 

        如何使用成员呢?

            成员变量：

                对象名.变量;

            成员方法：

                对象名.方法名(...);

 *

 */

public classTest {

    public static void main(String[] args) {

        //创建一个学生对象

        //类名  对象名 = new 类名();

        Students = newStudent();

       

        //打印一下这个学生对象的姓名和年龄

        //System.out.println(s.name);//null

        //System.out.println(s.age);//0

       

        //给学生对象的姓名和年龄赋值

        s.name = "刘德华";

        s.age = 50;

       

        System.out.println(s.name);//刘德华

        System.out.println(s.age);//50

       

        //试用一下学生的成员方法

        s.eat();

        s.makePlane();

        s.study();

       

    }

 

}

package com.edu_06;

 

public classPhone {

    //成员变量

    Stringbrand;

    int price;

   

    //成员方法

    public void call(String name){

        System.out.println(name+"正在给我打电话");

    }

   

    //玩游戏

    public void playGame(){

        System.out.println("手机可以玩游戏");

    }

 

}

package com.edu_06;

 

public classTest {

    public static void main(String[] args) {

        //创建手机对象

        Phonep = newPhone();

       

        //打印手机的品牌和价格

        System.out.println(p.brand);

        //null,因为brand是String类型，引用类型

        System.out.println(p.price);//0

       

        //给手机的成员变量赋值

        p.brand = "oppo";

        p.price = 2000;

       

        System.out.println(p.brand);

        System.out.println(p.price);

       

        //调用成员方法

        p.call("刘德华");

        p.playGame();

    }

 

}package com.edu_07;

/**

 * 如果一个文件中需要写多个类的话需要注意以下几点：

 * 1.main方法所在的类名必须和文件名相同

 * 2.类与类之间是平行关系

 */

 

public class PhoneTest{

    public static void main(String[] args) {

        //如何使用Phone这个类

        //创建对象使用里面的成员变量

        Phonep = newPhone();

       

        p.brand = "苹果";

        p.price = 5000;

       

        System.out.println(p.brand);

        System.out.println(p.price);

       

        //调用成员方法

        p.call();

        p.playGame();

       

    }

}

 

 

//定义一个手机类

class Phone{

    //成员变量

    Stringbrand;

    int price;

   

    //成员方法

    public void call(){

        System.out.println("刘德华给我打电话");

    }

   

    public void playGame(){

        System.out.println("郭德纲约我打游戏");

    }

   

}

 

 

package com.edu_08;

/**

 * 八：成员变量和局部变量的区别？

        A:在类中的位置不同

            成员变量类中方法外

            局部变量方法内或者方法声明上

        B:在内存中的位置不同

            成员变量堆内存

            局部变量栈内存      

        C:生命周期不同

            成员变量随着对象的存在而存在，随着对象的消失而消失

            局部变量随着方法的调用而存在，随着方法的调用完毕而消失

        D:初始化值

            成员变量有默认初始化值

            局部变量没有默认初始化值

 *

 */

public classVariableDemo {

   

    int age;//成员变量，位于类中方法外

   

    public void add(int a,int b){//局部变量位于方法中或者方法上

        int c = a+b;

        System.out.println(a+b);

    }

   

    public void show(){

        int d;

        //d是一个局部变量，在此时他并没有被初始化，没有被初始化的变量不能使用

        //局部变量系统不会给一个默认的初始化值

        //System.out.println(d);

    }

 

}

 

 

 

 

 

 

 

 

 

 

 

package com.edu_09;

 

public classMyMath {

   

    //创建一个加法

    public int add(int a,int b){

        return a+b;

    }

 

}

package com.edu_09;

/**

 * 十：匿名对象（学生案例代码进行演示）

    匿名对象：就是没有名字的对象

        是对象一种简写形式。

 

    应用场景：

        A:调用方法(对象调用方法仅仅一次的时候)

        B:作为实际参数传递

 *

 */

class Student{

    public void show(){

        System.out.println("student的show方法");

    }

}

 

 

class StudentDemo{

    public void method(Student s){//需要的实际参数一定是Student类的对象的的地址值

        s.show();

    }

}

 

 

public classStudentTest {

    public static void main(String[] args) {

/*      //我现在需要调用StudentDemo中的method()方法

        StudentDemosd = new StudentDemo();

        //需要的实际参数一定是Student类的对象的的地址值

        Students = new Student();

        sd.method(s);*/

       

        System.out.println("--------------------------");

        //想调用我现在需要调用StudentDemo中的method()方法

        //使用匿名对象调用方法,并传递参数

        new StudentDemo().method(new Student());   

    }

 

}

package com.edu_09;

 

public classTest {

    public static void main(String[] args) {

        //创建MyMath类的实力对象

        MyMathmy = newMyMath();

        //调用里面的加法

        int sum = my.add(10, 20);

        System.out.println(sum);

    }

 

}