07-29

package com.atguigu.java;

/*

 * 一、理解“万事万物皆对象”

 * 1、在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

 * 2、涉及到java语言与前端html、后端数据库交互时，前后端结构在Java层面交互时，都体现为类、对象

 *

 * 二、内存解析的说明

 * 1、引用类型的变量，只可能存储两类值：null和地址值

 *

 * 三、匿名对象的使用

 * 1、理解：我们创建的对象，没有显示的赋给一个变量名。即为匿名变量

 * 2、特征：匿名对象只能调用一次

 *

 *

 * */

public class InstanceTest {

       /**

        * @param args

        */

       public static void main(String[] args) {

              phone p = new phone();

              System.out.println(p);

              p.sendEmail();

              p.playGame();

              new phone().price = 1999;

              new phone().showPrice();

              phoneMall mall = new phoneMall();

              mall.show(new phone());

       }

}

class phoneMall {

       public void show(phone phone) {

              phone.sendEmail();

              phone.playGame();

       }

}

class phone {

       double price;

       public void sendEmail() {

              System.out.println("发送邮件");

       }

       public void playGame() {

              System.out.println("玩游戏");

       }

       public void showPrice() {

              System.out.println("手机价格为" + price);

       }

}

package com.atguigu.java;

public class ArrayUtil {

       // 求数组的最大值

       public int getMax(int[] arr) {

              return 0;

       }

       // 求数组的最小值

       public int getMin(int[] arr) {

              return 0;

       }

       // 求数组的总和

       public int getSum(int[] arr) {

              return 0;

       }

       // 求数组的平均值

       public int getAvg(int[] arr) {

              return 0;

       }

       // 反转数组

       public void reverse(int[] arr) {

       }

       // 复制数组

       public int[] copy(int[] arr) {

              return null;

       }

       // 数组排序

       public void sort(int[] arr) {

       }

       // 遍历数组

       public void print(int[] arr) {

       }

       // 查找数组

       public int getIndex(int[] arr, int dest) {

              return 0;

       }

}

package com.atguigu.java;

public class ArrayUtilTest {

       public static void main(String[] args) {

              ArrayUtil util = new ArrayUtil();

              int[] arr = new int[]{12,34,45,23,54,24};

             

              int max = util.getMax(arr);

              System.out.println(max);

             

              util.sort(arr);

             

             

              int index = util.getIndex(arr, 22);

              if(index >= 0){

                     System.out.println(index);

              }else{

                     System.out.println("meiyou");

              }

             

             

             

             

              package com.atguigu.java1;

/*

 *

 * 方法 的重载（overload）loading...

 *

 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可；

 *

 *

 *          "两同一不同"：同一个类、相同方法名

 *                               参数列表不同：参数个数不同，参数类型不同

 *

 * 2.举例：

 *          Arrays类中重载的sort（）/ binarySeaech（）

 *

 * 3.判断是否重载：

 *          跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

 *

 * 4.通过对象调用方法时，如何确定某一个指定的方法：

 *          方法名--->参数列表        

 *

 * */

public class OverLoadTest {

}

package com.atguigu.exer;

public class OverloadExer {

       public void mOL(int i){

              System.out.println(i*i);

       }

      

       public void mOL(int i,int j){

              System.out.println(i * j);

       }

      

       public void mOL(String s){

              System.out.println(s);

       }

      

      

       public int max(int i ,int j){

              return (i >j)? i : j;

       }

       public double max(double d1,double d2){

              return (di > d2)? d1:d2;

       }

      

      

}

             

             

       }

}

package com.atguigu.java1;

/*

 * 可变个数形参的方法

 *

 * 1、jdk5.0新增的内容 2、具体使用： 2.1可变个数形参的格式：数据类型 ...变量名

 * 2.2当调用可变个数形参的方法时，传入的参数个数可以是：0个、1个、2个 2.3可变个数形参是方法与本类中方法名相同时，形参不同的方法之间构成重载

 * 2.4可变个数形参的方法与本类中方法名类似，形参类型也相同的数组之间不构成重载，二者不能共存 2.5可变参数形参在方法的形参中，必须声明在末尾

 *

 *

 *

 */

public class MethodArgsTest {

       public static void main(String[] args) {

             

              MethodArgsTest test= new MethodArgsTest();

             

              test.show(3);

              test.show("sda");

              test.show("SDAD","SDDDDDDDDDA");

       }

      

      

       public void show(int i ){

             

       }

       public void show(String s)

       {

              System.out.println("show(String)");

       }

      

       public void show(String ...strings){

              System.out.println("show(String...strings)");

       }

      

package com.atguigu.java1;

/*

 * 方法形参的传递机制:值传递

 *

 * 1.形参：方法定义时，声明的小括号内的参数

 *   实参：方法调用时，实际传递给形参的数据

 *

 *

 * 2.值传递机制：

 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。

 *

 *

 *

 * */

public class ValueTransferTest {

       public static void main(String[] args) {

              int m = 10;

              int n = 20;

             

              System.out.println("m=" + m + "n=" +n);

             

             

      

             

              ValueTransferTest test = new ValueTransferTest();

              test.swap(10, 20);

             

              System.out.println("m" + m + " n" + n);

             

             

             

             

             

       }

      

      

      

       public void swap(int m ,int n){

              int temp = m ;

              m = n ;

              n = temp;

       }

       }

}

package com.atguigu.java1;

/*

 * 方法的形参的传递机制：值传递 1.形参：方法调用时，声明的小括号内的参数 实参：方法调用时，实际传递给形参是数据

 *

 *

 * 2.值传递机制： 如果参数是基本数据类型，此时实参赋给形参的是实参真是存储的数据值； 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值；

 *

 */

public class ValueTransferTest2 {

       public static void main(String[] args) {

              Data data = new Data();

              data.m = 10;

              data.n = 20;

              System.out.println("m = " + data.m + "    n =" + data.n);

              ValueTransferTest2 test = new ValueTransferTest2();

              test.swap(data);

              System.out.println("m = " + data.m + "    n =" + data.n);

       }

       public void swap(Data data) {

              int temp = data.m;

              data.m = data.n;

              data.n = temp;

       }

}

class Data {

       int m;

       int n;

}

package com.atguigu.exer;

public class Circle {

       double radius;

       public double findArea() {

              return Math.PI * radius * radius;

       }

}

package com.atguigu.exer;

public class PassObject {

       public static void main(String[] args) {

              PassObject test = new PassObject();

              Circle c = new Circle();

              test.prontAreas(c, 5);

       }

       public void prontAreas(Circle c, int time) {

              System.out.println("Radius\t\t");

              for (int i = 1; i <= time; i++) {

                     c.radius = i;

                     double area = c.findArea();

                     System.out.println(c.radius + " " + area);

              }

       }

}

package com.atguigu.java2;

public class RecursionTest {

       public static void main(String[] args) {

              RecursionTest test = new RecursionTest();

              int sum1 = test.getSum(100);

              System.out.println(sum1);

       }

       public int getSum(int n) {

              if (n == 1) {

                     return 1;

              } else {

                     return n + getSum(n - 1);

              }

       }

}