JAVA(69~83)

一、面向对象基础

1.认识面向对象  

开发一个个对象，把数据交给对象，再调用对象的方法来完成对数据的处理

创建对象的正确语法：类名 对象名=new 类名（）；且类名首字母要大写

对象本质上是一种特殊的数据结构

class也就是类，也称为对象的设计图（或对象的模板）

2.对象在计算机中的执行原理

Student s1= new Student()；

每次new student()，就是在堆内存中开辟一块内存区域代表一个学生对象

s1变量里面记住的是学生对象的地址，因此变量s1也称为引用类型变量

3.类和对象的注意事项

（1）类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，比如:Student、Car

（2）类中定义的变量也称成员变量(对象的属性)，类中定义的方法也称为成员方法(对象的行为）

（3）成员变量本身存在默认值，同学们在定义成员变量时一般来说不需要赋初始值(没有意义)

（4）一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须成

         为代码文件名

（5）对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了

（6）如果某个对象没有一个变量引用它，则该对象无法被操作了，该对象会成为所谓的垃圾对

象，java存在自动垃圾回收机制，会自动清除掉垃圾对象

4.this关键字

this是一个变量，可以用在方法中，来拿到当前对象

执行原理：

应用场景：主要用来解决变量名称冲突问题

5.构造器

是一种特殊的方法，名字必须与所在类的名字一样，且不能写返回值类型

一个类中可以写多个构造器（参数列表不能一样）

public class Student{
    //无参数构造器
    public Student(){
    }
    //有参数构造器
    public Student(String name,double score){
    }
}

特点：创建对象时，对象会去调用构造器 

           Student s=new Student（）；

应用场景：创建对象时，同时完成对对象成员变量（属性）的初始化赋值

注意事项：

                1.类在设计时，如果不写构造器，Java是会为类自动生成一个无参构造器的

                2.一旦定义了有参数构造器，java就不会帮我们的类自动生成无参构造器了，此时就建议

                  自己手写一个无参数构造器

6.封装

面向对象的三大特性：封装、继承、多态

所谓封装，就是用类设计对象处理某一个事物的数据时，应该把要处理的数据，以及处理数据的方

        法，设计到一个对象中去

设计规范：合理隐藏，合理暴露

使用public和private修饰符来公开和隐藏

7.实体JAVABean

实体类：是一种特殊的类，满足以下要求：

1.类中的成员变量都要私有，并且要对外提供相应的getXxx，setXxx方法

2.类中必须要有一个公共的无参的构造器

提供相应的getXxx，setXxx方法快捷键：

        右键选generat，再选getter and setter，选中一个变量，按住shift即可同时选中多个变量 

生成对应有参数构造器快捷键：

        右键选constructor，选中一个变量，按住shift即可同时选中多个变量

生成对应无参数构造器快捷键：

        右键选constructor，选择最下方的select none，即可生成无参数构造器

应用场景：在实际开发中，实体类仅仅只用来封装数据，而对数据的处理交给其他类来完成，以实

                  现数据和数据业务处理相分离

一个数据存取（student），一个数据处理（studentOperator），一个main中调用（test）

8.案例

让一段代码进入死循环的快捷键：

        选中需要进入死循环的代码，按ctrl+alt+t，选择while

（1）定义电影类

        首先每一部电影，都包含这部电影的相关信息，比如：电影的编号（id）、电影名称

（name）、电影的价格（price）、电影的分数（score）、电影的导演（director）、电影的主演

（actor）、电影的简介（info）

public class Movie {
    private int id;
    private String name;
    private double price;
    private double score;
    private String director;
    private String actor;
    private String info;

    public Movie() {
    }

    public Movie(int id, String name, double price, double score, String director, String actor, String info) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.score = score;
        this.director = director;
        this.actor = actor;
        this.info = info;
    }

    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;
    }

    public double getPrice() {
        return price;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
}

（2） 定义电影操作类

        前面我们定义的Movie类，仅仅只是用来封装每一部电影的信息。为了让电影数据和电影数据

的操作相分离，我们还得有一个电影操作类（MovieOperator）

        因为系统中有多部电影，所以电影操作类中MovieOperator，需要有一个Movie[] movies; 用

来存储多部电影对象；

        同时在MovieOperator类中，提供对外提供，对电影数组进行操作的方法。如

printAllMovies()用于打印数组中所有的电影信息，searchMovieById(int id)方法根据id查找一

个电影的信息并打印

public class MovieOperator {
    //因为系统中有多部电影，所以电影操作类中，需要有一个Movie的数组
    private Movie[] movies;
    public MovieOperator(Movie[] movies){
        this.movies = movies;
    }

    /** 1、展示系统全部电影信息 movies = [m1, m2, m3, ...]*/
    public void printAllMovies(){
        System.out.println("-----系统全部电影信息如下：-------");
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            System.out.println("编号：" + m.getId());
            System.out.println("名称：" + m.getName());
            System.out.println("价格：" + m.getPrice());
            System.out.println("------------------------");
        }
    }

    /** 2、根据电影的编号查询出该电影的详细信息并展示 */
    public void searchMovieById(int id){
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            if(m.getId() == id){
                System.out.println("该电影详情如下：");
                System.out.println("编号：" + m.getId());
                System.out.println("名称：" + m.getName());
                System.out.println("价格：" + m.getPrice());
                System.out.println("得分：" + m.getScore());
                System.out.println("导演：" + m.getDirector());
                System.out.println("主演：" + m.getActor());
                System.out.println("其他信息：" + m.getInfo());
                return; // 已经找到了电影信息，没有必要再执行了
            }
        }
        System.out.println("没有该电影信息~");
    }
}

 （3）定义测试类

        最后，我们需要在测试类中，准备好所有的电影数据，并用一个数组保存起来。每一部电影

的数据可以封装成一个对象。然后把对象用数组存起来即可

public class Test {
    public static void main(String[] args) {
        //创建一个Movie类型的数组
        Movie[] movies = new Movie[4];
        //创建4个电影对象，分别存储到movies数组中
        movies[0] = new Movie(1,"水门桥", 38.9, 9.8, "徐克", "吴京","12万人想看");
        movies[1] = new Movie(2, "出拳吧", 39, 7.8, "唐晓白", "田雨","3.5万人想看");
        movies[2] = new Movie(3,"月球陨落", 42, 7.9, "罗兰", "贝瑞","17.9万人想看");
        movies[3] = new Movie(4,"一点就到家", 35, 8.7, "许宏宇", "刘昊然","10.8万人想看");
        
    }
}

        准备好测试数据之后，接下来就需要对电影数据进行操作。我们已经把对电影操作先关的功

能写到了MovieOperator类中，所以接下来，创建MovieOperator类对象，调用方法就可以完成相

关功能，继续再main方法中，接着写下面的代码

// 4、创建一个电影操作类的对象，接收电影数据，并对其进行业务处理
MovieOperator operator = new MovieOperator(movies);
Scanner sc = new Scanner(System.in);
while (true) {
    System.out.println("==电影信息系统==");
    System.out.println("1、查询全部电影信息");
    System.out.println("2、根据id查询某个电影的详细信息展示");
    System.out.println("请您输入操作命令：");
    int command = sc.nextInt();
    switch (command) {
        case 1:
            // 展示全部电影信息
            operator.printAllMovies();
            break;
        case 2:
            // 根据id查询某个电影的详细信息展示
            System.out.println("请您输入查询的电影id:");
            int id = sc.nextInt();
            operator.searchMovieById(id);
            break;
        default:
            System.out.println("您输入的命令有问题~~");
    }
}

8.成员变量和局部变量的区别

成员变量在类中方法外，而局部变量在方法中

二、常用的APl

API（全称：Application Programming Interface：应用程序编程接口）

是别人写好的程序，给程序员调用，方便完成一些功能的

1.包Package

包是用来分门别类的管理各种不同程序的，类似文件夹，建包有利于程序的管理和维护

建包的语法规则：

//类文件的第一行定义包
package com.itheima.javabean;

public class 类名{
    
}

在自己的程序调用其他包下的程序的注意事项

（1）如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互

         相可以直接调用）

（2）如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包, 才可以访问

         导包格式：import 包名.类名

（3）如果当前程序中，要调用Java.lang包下的程序，不需要我们导包的，可以直接使用

（4）如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入

         一个程序，另一个程序必须带包名访问

2.String类

String类代表字符串，可以用来创建对象封装字符串数据，并对其进行处理

对于字符串的操作，只需要创建字符串对象，用字符串对象封装字符串数据，然后调用String类的

方法就可以了

对字符串处理的步骤：

（1）创建对象    （2）封装字符串数据   （3）调string的方法

String创建对象封装字符串数据的方式：

法一：java程序中的所有字符串文字（如“abc”）都为此类的对象

String s1 = "abc"; //这里"abc"就是一个字符串对象，用s1变量接收

String s2 = "黑马程序员"; //这里的“黑马程序员”也是一个字符串对象，用s2变量接收

法二：调用String类的构造器初始化字符串对象

String提供的操作字符串数据的常用方法：

public class StringDemo2 {
    public static void main(String[] args) {
        //目标：快速熟悉String提供的处理字符串的常用方法。
        String s = "黑马Java";
        // 1、获取字符串的长度
        System.out.println(s.length());

        // 2、提取字符串中某个索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);

        // 字符串的遍历
        for (int i = 0; i < s.length(); i++) {
            // i = 0 1 2 3 4 5
            char ch = s.charAt(i);
            System.out.println(ch);
        }

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

        // 3、把字符串转换成字符数组，再进行遍历
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        // 4、判断字符串内容，内容一样就返回true
        String s1 = new String("黑马");
        String s2 = new String("黑马");
        System.out.println(s1 == s2); // false
        System.out.println(s1.equals(s2)); // true

        // 5、忽略大小写比较字符串内容
        String c1 = "34AeFG";
        String c2 = "34aEfg";
        System.out.println(c1.equals(c2)); // false
        System.out.println(c1.equalsIgnoreCase(c2)); // true

        // 6、截取字符串内容 (包前不包后的)
        String s3 = "Java是最好的编程语言之一";
        String rs = s3.substring(0, 8);
        System.out.println(rs);

        // 7、从当前索引位置一直截取到字符串的末尾
        String rs2 = s3.substring(5);
        System.out.println(rs2);

        // 8、把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们
        String info = "这个电影简直是个垃圾，垃圾电影！！";
        String rs3 = info.replace("垃圾", "**");
        System.out.println(rs3);

        // 9、判断字符串中是否包含某个关键字
        String info2 = "Java是最好的编程语言之一，我爱Java,Java不爱我！";
        System.out.println(info2.contains("Java"));//true
        System.out.println(info2.contains("java"));//false
        System.out.println(info2.contains("Java2"));//false

        // 10、判断字符串是否以某个字符串开头。
        String rs4 = "张三丰";
        System.out.println(rs4.startsWith("张"));//true
        System.out.println(rs4.startsWith("张三"));//true
        System.out.println(rs4.startsWith("张三2"));//false

        // 11、把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
        String rs5 = "张无忌,周芷若,殷素素,赵敏";
        String[] names = rs5.split(",");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

注意事项：

（1）String对象的内容不可改变，被称为不可变字符串对象

       解释： 每次试图改变字符串对象实际上是新产生了新的字符串对象了，变量每次都是指向了

新的字符串对象，之前字符串对象的内容确实是没有改变的，因此说string的对象是不可变的

（2）若以“...”（双引号）方式写出的字符串对象，会存储到字符串常量池中，且相同内容的字符串

只存一份但是通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中

案例：

字面量的字符串计算出来的数据放在常量池；带变量的字符串计算后放在堆内存中

3.ArrayList类

（1）ArrayList表示一种集合，它是一个容器，用来装数据的，类似于数组

（2）数组一旦创建，长度不变，就只能存储固定元素个数，而集合是大小可变的，想要存储几个

元素就存储几个元素，在实际工作中用得更多

（3）是集合中最常用的一种，ArrayList是泛型类，可以约束存储的数据类型

（4）创建对象，调用无参数构造器初始化对象：public ArrayList()；

（5）集合的种类：

该如何学习集合

   “增删改查”

ArrayList<E>

public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 1、创建一个ArrayList的集合对象
        // ArrayList<String> list = new ArrayList<String>();
        // 从jdk 1.7开始才支持的
        ArrayList<String> list = new ArrayList<>();

        list.add("黑马");
        list.add("黑马");
        list.add("Java");
        System.out.println(list);

        // 2、往集合中的某个索引位置处添加一个数据
        list.add(1, "MySQL");
        System.out.println(list);

        // 3、根据索引获取集合中某个索引位置处的值
        String rs = list.get(1);
        System.out.println(rs);

        // 4、获取集合的大小（返回集合中存储的元素个数）
        System.out.println(list.size());

        // 5、根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
        System.out.println(list.remove(1));
        System.out.println(list);

        // 6、直接删除某个元素值，删除成功会返回true，反之
        System.out.println(list.remove("Java"));
        System.out.println(list);

        list.add(1, "html");
        System.out.println(list);

        // 默认删除的是第一次出现的这个黑马的数据的
        System.out.println(list.remove("黑马"));
        System.out.println(list);

        // 7、修改某个索引位置处的数据，修改后会返回原来的值给我们
        System.out.println(list.set(1, "黑马程序员"));
        System.out.println(list);
    }
}