06_可变参数_递归_类和对象_封装

第一章.可变参数

1.需求:定义一个方法,实现若干个整数相加
  参数:类型确定了,但是个数不确定

1介绍和基本使用

1.格式:
  数据类型...变量名
2.本质:数组
3.注意:
  参数位置只能有一个可变参数,而且只能放到最后

public class Demo01Var {
    public static void main(String[] args) {
        add(1, 2, 3, 4, 5);//new int[]{1,2,3,4,5}
    }

    public static void add(int data,int... arr) {//int[] arr
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        System.out.println(sum);
    }
}

2.练习

2.1.字符串拼接

需求一：返回n个字符串拼接结果，如果没有传入字符串，那么返回空字符串""

public class Demo02Var {
    public static void main(String[] args) {
        String result = concat("张三", "李四", "王五", "赵六", "田七", "朱八");
        System.out.println(result);
    }
    public static String concat(String...s){
        //定义一个空字符串
        String str = "";
        for (int i = 0; i < s.length; i++) {
            str+=s[i];
        }
        return str;
    }
}

2.2.字符串拼接分隔符

n个字符串进行拼接，每一个字符串之间使用某字符进行分隔，如果没有传入字符串，那么返回空字符串""
concat("-","张三","李四","王五")  -> 返回的是 -> 张三-李四-王五

public class Demo03Var {
    public static void main(String[] args) {
        String result = concat("-", "张三", "李四", "王五", "赵六");
        System.out.println(result);
    }
    public static String concat(String sep,String...s){
        //定义一个空字符串
        String str = "";
        for (int i = 0; i < s.length; i++) {
            if (i == s.length-1){
                str+=s[i];
            }else{
                str+=s[i]+sep;
            }
        }
        return str;
    }
}

第二章.递归

1.概述:方法内部自己调用自己
2.表现形式:
  a.方法自己调用自己-> 最常见
  b.方法之间互相调用
3.注意:
  a.递归需要有出口,否则会出现"栈内存溢出"
  b.即使有出口,也不要递归太多次    

public class Demo01DiGui {
    public static void main(String[] args) {
        method();
    }
    public static void method(){
        method();
    }
}

1.用递归输出3到1

public class Demo02DiGui {
    public static void main(String[] args) {
        method(3);
    }
    public static void method(int n){
        if (n==1){
            System.out.println(n);
            return;//结束方法
        }
        System.out.println(n);
        n--;
        method(n);
    }
}

2.求n!

1.需求:求3的阶乘
  3*2*1
2.分析:
  a.定义一个方法,代表阶乘,参数代表多少的阶乘 -> method(n)
  b.找规律:
    method(3)  -> 3*method(2)
    method(2)  -> 2*method(1)
        
    method(n)  -> n*method(n-1)    
     

public class Demo03DiGui {
    public static void main(String[] args) {
        int result = method(3);
        System.out.println(result);
    }

    private static int method(int n) {
        if (n==1){
            return 1;
        }
        return n*method(n-1);
    }
}

示例三：计算斐波那契数列（Fibonacci）的第n个值

不死神兔
故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。
在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡
问：一对刚出生的兔子，一年内繁殖成多少对兔子?  144

规律：一个数等于前两个数之和，比如: 1 1 2 3 5 8 13 21 34 55…

分析:
  1.定义一个方法,代表生兔子的对数,参数为月份
  2.找规律
    method(1)   1
    method(2)   1
    method(3)   2   method(1)+method(2)
    method(4)   3   method(2)+method(3)
    method(5)   5   method(3)+method(4)
      
    method(n) =  method(n-1)+method(n-2)   

public class Demo04DiGui {
    public static void main(String[] args) {
        int result = method(12);
        System.out.println(result);
    }

    private static int method(int n) {
        if (n==1||n==2){
            return 1;
        }
        return method(n-1)+method(n-2);
    }
}

第三章.类和对象

java核心编程思想:面向对象
  面向对象:自己的事情找对象去帮我们做   -> 编程简单
  面向过程:C语言的编程思想 -> 讲究的是自己的事情自己做

1.面向对象的介绍

1.什么是面向对象思想:java的核心编程思想
2.为啥使用面向对象思想:为了少写代码,很多功能别人写好了,我们只需要直接调用即可,至于人家怎么实现的,我们不需要关心
3.什么时候使用面向对象思想:
  调用别的类中的成员,就要使用面向对象思想编程
4.怎么使用面向对象思想编程:
  a.new对象,new完去点  -> 比如 new Scanner   new Random
  b.特殊:不用new对象,直接类名点   -> 适用于被点的成员上带static关键字 -> 比如Arrays System类

public class Demo01Object {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        /*
           next()方法就是Scanner这个对象实现好的功能
           我们直接new完调用,就可以实现键盘录入字符串
           至于人家怎么实现的,跟我没有关系
           只需要new,new完点
         */
        String data = sc.next();
        System.out.println(data);

        System.out.println("====================");
        int[] arr = {1,2,3,4,5};
        /*
           Arrays就是咱们找来的对象
           toString方法就是这个对象中实现好的功能
           我们直接调用,就可以实现数组的打印
           至于人家怎么实现的,跟我没有关系
         */
        System.out.println(Arrays.toString(arr));
    }
}

2.类和对象

2.1类(实体类)_class

1.概述:一类事物的抽象表示形式
2.类的分类:
  a.测试类 -> 带main方法的类,用于跑代码的,测试代码
  b.逻辑类 -> 写业务逻辑的
  c.实体类 -> 用于描述世间万物的分类

1.实体类包含的成员:
  属性(这个分类有啥)  -> 成员变量
    a.定义位置:类中方法外
    b.作用范围:整个这个类都能使用
    c.定义格式: 数据类型 变量名
    d.成员变量有默认值 
      整数  0
      小数  0.0
      字符 '\u0000'
      布尔 false
      引用  null
 
  行为(这个分类能干啥) -> 成员方法
      将之前定义的方法中的static干掉

public class Person {
    //属性
    String name;//null
    int age;//0
    
    //行为
    public void eat(){
        System.out.println("人要吃饭");
    }
    public  void drink(){
        System.out.println("人要喝水");
    }
    public  void la(){
        System.out.println("人要拉屎");
    }
    public  void sa(){
        System.out.println("人要撒尿");
    }
}

描述动物类

public class Animal { 
    //属性
    String brand;
    int age;
    
    //行为
    public String run(){
        return "动物在跑";
    }
    
    public String eat(){
        return "动物在吃";
    }
}

描述手机类

public class Phone {
   //属性
   String brand;
   double price;
   String color;
   
   //行为
   public void call(String name){
       System.out.println("给"+name+"打电话");
   }
   
   public String message(String name){
       return "给"+name+"发短信";
   }
}

2.2.对象

1.概述:一类事物的具体体现
2.使用:
  a.导包:import 包名.类名
    如果两个类在同一个包下,使用对方的成员不需要导包
    如果两个类不在同一个包下,使用对方的成员需要导包
    特殊包:java.lang包  -> 使用lang包下的类不需要导包  
  b.创建对象:想使用哪个类中的成员,就new哪个类的对象
    类名 对象名 = new 类名()
  c.调用成员:想使用哪个类中的成员,就用哪个类的对象去点哪个成员
    对象名.成员名

public class Phone {
    //属性
    String brand;
    double price;
    String color;

    //行为
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }

    public String message(String name){
        return "给"+name+"发短信";
    }
}

public class Demo02Object {
    public static void main(String[] args) {
        //创建对象 类名 对象名 = new 类名()
        Phone phone1 = new Phone();
        phone1.brand = "华为";
        phone1.price = 8888;
        phone1.color = "黑色";
        System.out.println(phone1.brand);
        System.out.println(phone1.price);
        System.out.println(phone1.color);

        phone1.call("金莲");

        String result = phone1.message("大郎");
        System.out.println(result);
    }
}

3.匿名对象的使用

int i = 10
a.等号左边的int:数据类型
b.i:变量名
c.等号右边的:真实的数据
    
Person p = new Person()
a.等号左边的Person:数据类型,相当于int
b.p:变量名
c.等号右边的new Person():真实的数据,是一个真实的对象
  

1.匿名对象的概述:new对象的时候没有等号左边的部分,相当于对象没有名字,只有new 类名()
  a.Person p = new Person()  有名的对象
  b.new Person() 匿名的对象
2.注意:
  a.如果只让一个方法简单执行,就可以使用匿名对象
  b.但是如果涉及到赋值了,千万不要使用,因为匿名对象都是一次性的

public class Person {
    //属性
    String name;//null
    int age;//0

    //行为
    public  void eat(){
        System.out.println("人要吃饭");
    }
    public  void drink(){
        System.out.println("人要喝水");
    }
    public  void la(){
        System.out.println("人要拉屎");
    }
    public  void sa(){
        System.out.println("人要撒尿");
    }
}

public class Demo03Object {
    public static void main(String[] args) {
        //有名的对象
        Person p = new Person();
        p.name = "张三";
        System.out.println(p.name);
        p.eat();

        System.out.println("=================");
        //匿名对象
        new Person().eat();

        new Person().name = "李四";
        System.out.println(new Person().name);//null
    }
}

4.一个对象的内存图

public class Phone {
    String brand;
    int price;
    public void call(){
        System.out.println("打电话");
    }
}

public class{
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone);//地址值
        System.out.println(phone.brand);// null
        System.out.println(phone.price);// 0
        phone.brand = "华为";
        phone.price = 8888;
        System.out.println(phone.brand);// 华为
        System.out.println(phone.price);// 8888
        phone.call();
    }
}

5.两个对象的内存图

phone1和phone2是两个不同的对象,在堆内存中开辟了两个不同的空间,操作一个空间中的数据不会影响另外一个空间中的数据

6.两个对象指向同一片空间内存图

phone2不是new出来的,而是phone1直接给的,所以此时会将phone1的地址值给phone2,此时两个对象指向了同一片空间,所以修改一个对象的数据会影响到另外一个对象

第四章.成员变量和局部变量区别

1.定义位置不同
  a.成员变量:类中方法外
  b.局部变量:在方法内,或者参数位置
2.作用范围不同:
  a.成员变量:作用于整个类
  b.局部变量:只作用于自己所在的方法内部
3.初始化值不同:
  a.成员变量:有默认值的
  b.局部变量:没有默认值,必须赋值之后才能使用
4.内存位置不同:
  a.成员变量:在堆中
  b.局部变量:在栈中    
5.生命周期不同:
  a.成员变量:随着对象的创建而创建,随着对象的消失而消失
  b.局部变量:随着方法的调用而创建,随着方法调用完毕而消失    

第五章.封装

1.面向对象编程为了:少写代码
2.面向对象有三大特征:封装    继承     多态
3.面向对象思想和封装,继承,多态的关系:
  面向对象思想编程是为了少写代码,而封装,继承,多态是少写代码的具体方式

1.封装的介绍以及使用

1.封装的概述:
  将细节隐藏起来(为了不让外界直接使用),对外提供一套公共的接口(让外界通过这个公共的接口间接使用封装起来的细节),这种思想就是封装
      
2.封装的表现形式:
  a.表现形式1:将一段代码放到一个方法中,方法体就是隐藏的细节,方法名就是对外提供的接口,我们直接调用方法名,内部的方法体就执行了,至于这个方法底层怎么写的,我们不需要考虑,我们直接调用方法名就行了
  b.表现形式2:代表性关键字:private(私有权限)
      
3.private关键字:
  a.概述:代表的是私有权限
  b.作用:被private修饰的成员(成员变量,成员方法),只能在本类中使用,别的类不能调用
  c.被private修饰之后,需要提供公共的接口:
    get/set方法
        
    setxxx:为属性赋值
    getxxx:获取属性值

public class Person {
    //隐藏细节
    private String name;
    private int age;

    /**
     * 为name提供公共的接口
     */
    public void setName(String xingMing){
        name = xingMing;
    }
    public String getName(){
        return name;
    }

    /**
     * 为age提供公共的接口
     */
    public void setAge(int nianLing){
        age = nianLing;
    }
    public int getAge(){
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "张三";
        //person.age = 18;
        //System.out.println(person.name+"..."+person.age);
        person.setName("张三");
        person.setAge(18);
        System.out.println(person.getName()+"..."+person.getAge());
    }
}

一个类中如果有私有属性,get/set方法基本就是配套提供的

2.this的介绍

1.注意:
  如果成员变量和局部变量重名,遵循"就近原则"访问,先访问局部变量
2.this:
  a.概述:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)
  b.作用:区分重名的成员变量和局部变量 -> this.后面的一定是成员的    

public class Person {
    String name;
    public void speak(String name){
        System.out.println(this+"...");
        System.out.println(this.name+"您好,我是"+name);
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+"......");
        person.name = "沉香";
        person.speak("刘彦昌");

        System.out.println("================");
        Person person2 = new Person();
        System.out.println(person2+"......");
        person2.name = "哪吒";
        person2.speak("李靖");
    }
}

public class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("张三");
        p1.setAge(18);
        System.out.println(p1.getName()+"..."+p1.getAge());

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

        Person p2 = new Person();
        p2.setName("李四");
        p2.setAge(19);
        System.out.println(p2.getName()+"..."+p2.getAge());
    }
}

问题:属性没有被私有化的时候能不能提供get/set方法呢

​ 其实是可以的,但是没有意义

3.构造方法_构造器

 1.特点:
  a.方法名和类名一致
  b.构造方法没有返回值,连void都没有
  c.我们一new就相当于调用了构造方法

3.1空参构造

1.格式:
  pubilc 类名(){
      
  }

2.作用:
  new对象,初始化对象中的属性值
3.特点:
  每个类中有会默认有一个无参构造,即使不写,jvm会自动提供一个

public class Person {
    private String name;
    private int age;

    /**
     * 无参构造
     */
    public Person(){
        System.out.println("我是无参构造");
    }

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person();
    }
}

3.2有参构造

1.格式:
  public 类名(形参){
      为属性赋值
  }
2.作用:
  new对象的同时为属性赋值
      
3.特点:
  如果写了有参构造,jvm将不再提供无参构造,所以建议都写上

public class Person {
    private String name;
    private int age;

    /**
     * 无参构造
     */
    public Person(){
    }

    /**
     * 有参构造
     */
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person();

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

        //利用有参构造创建对象
        Person p2 = new Person("张三", 18);
        System.out.println(p2.getName()+"..."+p2.getAge());
    }
}

4.标准JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：

（1）类必须是具体的(非抽象 abstract)和公共的，public class 类名

（2）并且具有无参数的构造方法

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

com.atguigu.controller -> 存放和页面打交道的类

com.atguigu.service -> 存放业务类

com.atguigu.dao -> 存放和数据库打交道的类

com.atguigu.pojo/entity -> 存放的都是javabean类

com.atguigu.utils -> 存放的都是工具类

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student {
    private int id;
    private String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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