java学习笔记10
登录
标签搜索
侧边栏壁纸
博主昵称
bandao

  • 累计撰写 19 篇文章
  • 累计收到 1 条评论
java学习笔记

java学习笔记10

bandao
bandao
2021-12-12 / 0 评论 / 114 阅读 / 正在检测是否收录...

1. 理解“万事万物皆对象”

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

Scanner,String等
文件：File
网络资源：URL

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

2、内存解析的说明

引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

3. 匿名对象的使用

  1. 理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
  2. 特征：匿名对象只能调用一次。

  3. java代码

    package com.atguigu.java;

/**
 * @description: 匿名对象
 * @author: kkx
 * @create: 2021-12-12 12:59
 **/
public class InstanceTest {
 public static void main(String[] args) {
     Phone p = new Phone();
     p.playGame();

     new Phone().playGame();
     new Phone().price = 1999;
     new Phone().showPrice();        //0.0

     //常用
     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);
 }
}

    4. 自定义工具类的封装

    package com.atguigu.java;

/**
 * @description: 工具类的封装
 * @author: kkx
 * @create: 2021-12-12 13:38
 **/
public class ArrayUtil {
 // 求数组的最大值
 public int getMax(int[] arr){
     int maxValue = arr[0];
     for (int i = 1; i < arr.length; i++) {
         if (maxValue < arr[i]) {
             maxValue = arr[i];
         }
     }
     return maxValue;
 }
 // 求数组的最小值
 public int getMin(int[] arr){
     int minValue = arr[0];
     for (int i = 1; i < arr.length; i++) {
         if (minValue > arr[i]) {
             minValue = arr[i];
         }
     }
     return minValue;
 }
 // 求数组的总和
 public int getSum(int[] arr){
     int sum = 0;
     for (int i = 0; i < arr.length; i++) {
         sum += arr[i];
     }
     return sum;
 }
 // 求数组的平均值
 public int getAvg(int[] arr){
     return getSum(arr) / arr.length;
 }

 //如下的两个同名方法构成了重载
 // 反转数组
 public void reverse(int[] arr){
     for (int i = 0; i < arr.length / 2; i++) {
         int temp = arr[i];
         arr[i] = arr[arr.length - i - 1];
         arr[arr.length - i - 1] = temp;
     }
 }
 public void reverse(String[] arr){
 }
 // 复制数组
 public int[] copy(int[] arr) {
     int[] arr1 = new int[arr.length];
     for (int i = 0; i < arr1.length; i++) {
         arr1[i] = arr[i];
     }
     return arr1;
 }
 // 数组排序
 public void sort(int[] arr){
     // 冒泡排序
     for (int i = 0; i < arr.length - 1; i++) {
         for (int j = 0; j < arr.length - 1 - i; j++) {
             if (arr[j] > arr[j + 1]) {
                 int temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
             }
         }
     }
 }
 // 遍历数组
 public void print(int[] arr) {
     for (int i = 0; i < arr.length; i++) {
         System.out.print(arr[i] + "\t");
     }
     System.out.println();
 }
 // 查找指定元素
 public int getIndex(int[] arr, int dest){
     // 线性查找：
     for (int i = 0; i < arr.length; i++) {
         if (dest == arr[i]) {
             return i;
         }
     }
     return -1;//返回一个负数，表示没有找到
 }
}
    package com.atguigu.java;

/**
 * @description: 使用自定义工具类
 * @author: kkx
 * @create: 2021-12-12 13:44
 **/
public class ArrayUtilTest {
 public static void main(String[] args) {
     ArrayUtil util = new ArrayUtil();
     int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};

     System.out.println("最大值为" + util.getMax(arr));

     System.out.println("排序前：");
     util.print(arr);
     util.sort(arr);
     System.out.println("排序后：");
     util.print(arr);

     System.out.println("查找：");
     int index = util.getIndex(arr, -5);
     if(index >= 0){
         System.out.println("找到了，索引地址为：" + index);
     }else{
         System.out.println("未找到");
     }

     util.reverse(arr);
 }
}

    5. 方法的重载

    1. 定义：

    在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
    "两同一不同":同一个类、相同方法名
    参数列表不同：参数个数不同，参数类型不同

    2. 举例：Arrays类中重载的sort() / binarySearch()

    3. 判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

    4. 在通过对象调用方法时，通过方法名和参数列表确定方法

    5. java代码

    package com.atguigu.java1;

/**
 * @description: 方法的重载
 * @author: kkx
 * @create: 2021-12-12 13:56
 **/
public class OverLoadTest {
 public static void main(String[] args) {
     OverLoadTest test = new OverLoadTest();
     test.getSum(1, 2);      //1
     test.getSum(1.0, 2.0);         //2
 }

 //如果没有这个方法，则提升为double的方法
 public void getSum(int i, int j){
     System.out.println(1);
 }
 public void getSum(double d1, double d2){
     System.out.println(2);
 }
 //传参数有顺序要求，顺序不一样也重载
 public void getSum(String s ,int i){
     System.out.println(3);
 }
 public void getSum(int i,String s){
     System.out.println(4);
 }

 /*
 如下的3个方法不能与上述4个方法构成重载
 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
 public int getSum(int i,int j){
     return 0;
 }
 public void getSum(int m,int n){

 }
 private void getSum(int i,int j){

 }
  */
}

    6. 可变个数形参的方法

  4. 可变个数形参的格式：数据类型 ... 变量名
  5. 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
  6. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
  7. 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。
  8. 可变个数形参在方法的形参中，必须声明在末尾

  9. 可变个数形参在方法的形参中,最多只能声明一个可变形参。

    package com.atguigu.java1;

import java.util.Arrays;

/**
 * @program: project10
 * @description: 可变个数形参的方法
 * @author: kkx
 * @create: 2021-12-13 20:51
 **/
public class MethodArgsTest {
 public static void main(String[] args) {
     MethodArgsTest test = new MethodArgsTest();
     test.show("hello world");
     test.show(new String[]{"AA", "BB"});
 }

 public void show(String s){
     System.out.println("String s");
 }
 public void show(String ... strings){
     System.out.println("String ... strings");
     System.out.println(Arrays.toString(strings));
 }
 //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
}

    7. 关于变量的赋值

  10. 基本数据类型，此时赋值的是变量所保存的数据值。

  11. 引用数据类型，此时赋值的是变量所保存的数据的地址值。

    package com.atguigu.java1;

/**
 * @program: project10
 * @description: 关于变量的赋值
 * @author: kkx
 * @create: 2021-12-13 22:41
 **/
public class ValueTransferTest {
 public static void main(String[] args) {
     int m = 10;
     int n = m;
     System.out.println(m + "\t"+ n);
     
     n = 20;
     System.out.println(m + "\t"+ n);

     Order o1 = new Order();
     o1.orderId = 1001;
     Order o2 = o1;//赋值以后，o1和o2的地址值相同
     System.out.println(o1.orderId + "\t" + o2.orderId);

     o2.orderId = 1002;
     System.out.println(o1.orderId + "\t" + o2.orderId);
 }
}
class Order{
 int orderId;
}
    package com.atguigu.java1;

/**
 * @program: project10
 * @description: 方法的形参的传递机制：值传递
 * @author: kkx
 * @create: 2021-12-13 23:12
 **/
public class ValueTransferTest1 {
 public static void main(String[] args) {
     int m = 10;
     int n = 20;
     System.out.println(m + "\t" + n);       //10    20

     ValueTransferTest1 test = new ValueTransferTest1();
     test.swap(m, n);
     System.out.println(m + "\t" + n);       //10    20
 }

 public void swap(int m, int n){
     int temp = m;
     m = n;
     n = temp;
 }
}
    package com.atguigu.java1;

/**
 * @program: project10
 * @description: 实现交换
 * @author: kkx
 * @create: 2021-12-13 23:40
 **/
public class ValueTransferTest2 {
 public static void main(String[] args) {
     Data data = new Data();
     data.m = 10;
     data.n = 20;
     System.out.println(data.m + "\t" + data.n);    //10    20

     ValueTransferTest2 test = new ValueTransferTest2();
     test.swap(data);
     System.out.println(data.m + "\t" + data.n);    //20    10
 }
 public void swap(Data data){
     int temp = data.m;
     data.m = data.n;
     data.n = temp;
 }
}
class Data{
 int m;
 int n;
}

    8. 面试题

    /**
 * @program: project10
 * @description: 面试坑1
 * @author: kkx
 * @create: 2021-12-14 23:34
 **/
public class test {
 public static void main(String[] args) {
     int a = 10;
     int b = 10;
     method(a, b);       //仅输出a = 100,b = 200
     System.out.println("a=" + a);
     System.out.println("b=" + b);
 }
 public static void method(int a, int b){
     //自己编写
     a = a * 10;
     b = b * 20;
     System.out.println(a);
     System.out.println(b);
     System.exit(0);
 }
}
    /**
 * @program: project10
 * @description: 面试坑2
 * @author: kkx
 * @create: 2021-12-14 23:39
 **/
public class test1 {
 public static void main(String[] args) {
     int[] arr = new int[]{1, 2, 3};
     System.out.println(arr);        //地址值
     char[] arr1 = new char[]{'a', 'b', 'c'};
     System.out.println(arr1);       //abc
 }
}

    9. 递归

  12. 递归方法：一个方法体内调用它自身。

  13. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
    递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

    package com.atguigu.java1;

/**
 * @program: project10
 * @description: 递归
 * @author: kkx
 * @create: 2021-12-17 00:35
 **/
public class RecursionTest {
 public static void main(String[] args) {
     // 例1：计算1-100之间所有自然数的和
     // 方式一：
     int sum = 0;
     for (int i = 1; i <= 100; i++) {
         sum += i;
     }
     System.out.println(sum);
     // 方式二：
     RecursionTest test = new RecursionTest();
     System.out.println(test.getSum1(100));
     System.out.println(test.f(10));
     System.out.println(test.fibonacci(10));
 }
 // 例1：计算1-n之间所有自然数的和
 public int getSum(int n){
     if (n == 1){
         return 1;
     }else {
         return n + getSum(n - 1);
     }
 }
 // 例2：计算1-n之间所有自然数的乘积:n!
 public int getSum1(int n){
     if (n == 1){
         return 1;
     }else {
         return n * getSum(n - 1);
     }
 }
 //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
 public int f(int n){
     if (n == 0){
         return 1;
     }else if(n == 1){
         return 4;
     }else {
         return 2 * f(n - 1) + f(n - 2);
     }
 }
 //例4：斐波那契数列
 public int fibonacci(int n){
     if (n == 0){
         return 0;
     }else if(n == 1){
         return 1;
     }else {
         return fibonacci(n - 1) + fibonacci(n - 2);
     }
 }
 //例5：汉诺塔问题
 //例6：快排
}
0
java基础类
版权属于： bandao
本文链接： https://joe.bandao.ltd/coding/java/note/10.html
作品采用： 《 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 》许可协议授权
相关推荐
java学习笔记12
java学习笔记12
 java project 客户管理信息软件
java project 客户管理信息软件
 java学习笔记9
java学习笔记9
 java学习笔记7
java学习笔记7

评论 (0)

取消