java第二周重难点合集

day_01

1. ArrayList:底层使用数组形式进行处理的集合

/**
 * ArrayList:
 *  是一个底层使用数组进行实现的,可以自动进行扩容的有序集合。初始容量为10,如果我们将元素
 *  已经存满了,java自动给我们的集合进行元素扩容。
 *
 *常用方法:
 *add(E e):将指定的元素追加到此列表的末尾。
 *add(int index, E element):在此列表中的指定位置插入指定的元素。
 *    int index:代表指定的下标
 *    E element:代表元素
 *addAll(Collection<? extends E> c)
 *      按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
 *      将一个集合中的所有的元素追加到另外一个集合末尾
 *addAll(int index, Collection<? extends E> c)
 *      将指定集合中的所有元素插入到此列表中，从指定的位置开始。
 * clear()
 *      从列表中删除所有元素。
 * get(int index)
 *      返回此列表中指定位置的元素。
 * indexOf(Object o)
 *      返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
 *      判断列表中是否有此元素
 * isEmpty()
 *      如果此列表不包含元素，则返回 true 。
 * remove(int index)
 *      删除该列表中指定位置的元
 素。
 * remove(Object o)
 *      从列表中删除指定元素的第一个出现（如果存在）。
 * set(int index, E element)
 *      用指定的元素替换此列表中指定位置的元素。
 *size()
 *      返回此列表中的元素数。
 * toArray()
 *      以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
 *      将集合转换为数组
 */
/**
         * 集合如何定义:
         *  ArrayList<引用数据类型> 集合名称 = new ArrayList<引用数据类型>();
         *  引用数据类型,如果想使用基本数据类型,那么就使用基本数据类型的封装类型
         *  如果你不定义数据类型,那么默认可以存储所有数据类型的元素
         *  基本数据类型                  封装类型
         *  byte                            Byte
         *  short                           Short
         *  int                             Integer
         *  long                            Long
         *  float                           Float
         *  double                          Double
         *  char                            Character
         *  boolean                         Boolean
         */

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("张三");
        list.add('牛');
        list.add(3);
        list.add(3.1415926);
        list.add(false);
        list.add(false);
        list.add(false);

        list.add(2,"李四");

        Object[] arr = list.toArray();

        System.out.println(Arrays.toString(arr));
        System.out.println("集合中的元素是的个数是:" + list.size());

        list.set(4,3.14);

        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + "\t");
        }
        System.out.println();


        list.remove("张三");
        Object[] arr2 = list.toArray();
        System.out.println(Arrays.toString(arr2));

        list.remove(1);
        Object[] arr3 = list.toArray();
        System.out.println(Arrays.toString(arr3));

        System.out.println("集合中是否有某一个元素:" + list.indexOf(false));

        System.out.println("判断集合中的元素是否为空:" + list.isEmpty());

        ArrayList<Integer> list1 = new ArrayList<Integer>();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        //将list1添加到list里面去,从末尾开始
        list.addAll(list1);

        for(int i = 0; i < list.size(); i++){
            System.out.print(list.get(i) + "\t");
        }
        System.out.println();

        //从指定的下标开始,将另外一个集合中的所有的元素全部添加进来
        list.addAll(2,list1);
        System.out.println(list.toString());

        //清除掉集合中所有的元素
        list.clear();
        System.out.println(list.toString());
    }

2.二维数组

public class Arr_01 {
   public static void main(String[] args) {
        /**
         * 数据类型[][] 数组名 = new 数据类型[m][n];
         *        m:二维数组中一维数组的个数
         *        n:一维数组中元素的个数
         */
        //在一个二维数组中,有3个一维数组,每一个一维数组中有2个元素
        //0 0     下标0
        //0 0     下标1
        //0 0     下标2
        int[][] arr = new int[3][2];
        //数组名[二维数组中一维数组的下标][一维数组中元素的下标];
        /*
          0 0     下标0
          0 100   下标1
          0 0     下标2
         */
        arr[1][1] = 100;

        //数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}...};
        String[][] name = {{"蔡徐坤","吴亦凡","李易峰"},
                           {"范冰冰","杨幂","迪丽热巴"},
                           {"丁真","王源","易烊千玺"}};
        System.out.println(name[1][1]);

        //数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...};
        String[][] name2 = new String[][]{{"乔峰","段誉","虚竹","慕容复"},
                                          {"杨过","郭靖","杨康"},
                                          {"高启强","高启盛","高启兰","安欣","老默"}};
        System.out.println("二维数组中一维数组的个数:" + name2.length);
        //数组名[一维数组的下标].length:二维数组中下标为几的一维数组的元素个数
        System.out.println("二维数组中第三个一维数组的元素个数:" + name2[2].length);
        name2[1][1] = "小龙女";

        //[[Ljava.lang.String;@4554617c, [Ljava.lang.String;@74a14482, [Ljava.lang.String;@1540e19d]
        //输出二维数组中每个一维数组的地址
        //
        System.out.println(Arrays.toString(name2[2]));
    }

/**
 * 关于二维数组的遍历
 */
public class Arr_02 {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3,4,5,6},
                       {11,22,33,44},
                       {111,222,333,444,555},
                       {21,22,23,24,25,26,27,28}};
        //使用for循环进行遍历
        //外层循环遍历二维数组中的一维数组
        //i代表二维数组中每个一维数组的下标
        for(int i = 0; i < arr.length; i++){
            //内层循环遍历一维数组中的元素
            //j代表二维数组中一维数组的元素的下标
            //arr[i]:我们遍历到的二维数组中的一维数组
            for(int j = 0; j < arr[i].length; j++){
                //二维数组中一维数组的元素内容表示
                System.out.print(arr[i][j] + "\t");
            }
        }

        System.out.println();//换行
        //使用foreach,对于二维数组来说,我们这里的数据类型是一个数组
        //对于当前的二维数组中的元素来说:int[]就是指一个数据类型,表示二维数组中的元素的数据类型
        //是一个整数类型的数组
        //for(数据类型 变量名 : 数组名)
        for(int[] n : arr){//n是用来存一维数组的
            //对变量n进行遍历,n是一个整数类型的数组,然后元素的数据类型是int类型
            for(int m : n){//m是用来存储从上面n中遍历出来的一维数组中的元素的
                System.out.print(m + "\t");
            }
        }
        System.out.println();

        for(int i = 0; i < arr.length; i++){//i代表二维数组中一维数组的下标
            //Arrays.toString(一维数组)
            System.out.println(Arrays.toString(arr[i]));
        }
    }

3.面向对象(封装、继承、多态)前置内容

3.1类

类(class):参与和值的传递,类必须具象化,比如:学生类就必须做到见名知意student所有的类都有特殊的含义。类里面主要就是属性和方法组成。

3.2属性

属性(可以当成之前的变量,但是是全局变量):

需要做到属性名称命名的时候见名知意,比如:年龄(age)

3.3 方法

方法是我们类中的功能集合,我们以后处理的每一个功能都是一个方法

方法的调用能够让我们的代码写起来更简单,调用更加简单,减少重复代码

/**
 * 方法:行为
 * 语法:
 *      访问控制修饰符 void/返回值的数据类型 方法名(数据类型 参数名,数据类型 参数名...){
 *          方法执行的主要内容;
 *          return 值;
 *      }
 * 访问控制修饰符:public(常用)、private、default、protected
 * void:没有返回值的
 * 返回值的数据类型:可以使用基本数据类型也可以使用引用数据类型
 * 方法名:按照标识符的命名规范来,单词全部小写,如果多个单词组成,从第二个开始首字母大写
 * 数据类型 参数名,数据类型 参数名...:参数列表
 * 方法执行的主要内容:除了方法里面不能新建方法其余都可以
 * return:返回的关键字
 * 值:返回值
 *
 * 注意事项:
 *  1、访问控制修饰符没有特殊要求就使用public
 *  2、除了几个特殊的方法以外,其余的方法基本都遵守这个语法
 *  3、void和返回值的数据类型只能有一种
 *  4、参数列表中的参数可以是多个,可以没有
 *  5、return在没有返回值的数据类型的时候,可以 省略 省略 省略 不写
 *  6、返回值的数据类型必须和"值"数据类型保持一致
 */
public class MethodDemo {
    /**
     * 按照参数的有无和返回值的有无我们可以将方法分为以下四种
     * 方法具体有没有参数和返回值是根据具体情况定的除了几个固定特殊方法其余的都是
     * 自己定义的,需要就添加,不需要就不管
     * 如果不会写,统统写无参数无返回值的,等到需要的时候自己添加
     */

    //计算两个整数相乘

    //无参数无返回值
    //没有参数意味着我们不能从外部进行传值
    //这个值只可能是类中定义的全局变量或者在方法中定义或者产生的值
    public void m1(){
        int a = 100;
        int b = 200;
        System.out.println(a * b);
    }

    //有参数无返回值
    public void m2(int a,int b){
        System.out.println(a * b);
    }
    //无参数有返回值
    public int m3(){
        int a = 100;
        int b = 100;
        int c = a * b;
        return c;
    }


    public static void main(String[] args) {
        //想要调用方法,必须先创建对象
        //类名 对象名 = new 构造方法名();
        MethodDemo md = new MethodDemo();
        //调用方法:对象名.方法名();
        md.m1();
        System.out.println("==========================");
        md.m2(100,200);
        System.out.println("==========================");
        //如果你的方法是有返回值数据类型的,那么想要看到结果就要将方法的执行过程放在输出语句里面
        System.out.println(md.m3() * 3);
        System.out.println("==========================");
        System.out.println(md.m5(123,456));
    }


    public int m5(int a,int b){
        return a  * b;
    }
}

3.4访问修饰符

四种访问控制修饰符:

public:公有的，整个项目中都可以使用

private:私有的，只有在本类中可以使用

default(package)::默认不写的，在本类中和同一个包中可以使用

protected:受保护的，在本类中,同一个包中,以及不同包的子类中创建子类自己的对象可以使用父类中protected修饰的元素

如果定义方法,没有特殊要求就使用public 公有的

如果定义属性,没有特殊要求就使用private 私有的

访问修饰符作用范围由大到小排列：public>protected>default>private

day_02

1. 面向对象

/**
 * 这个类用来学习构造方法
 * 构造方法是用来创建对象的,一共有两种,一种是有参数的,一种是没有参数
 * 分为:有参构造函数和无参构造函数
 * 构造函数在有类并且有属性的基础上进行处理,构造方法其实就是为了个属性赋值,
 * 有了属性才能有具体的对象
 *
 * 构造函数是一种特殊的方法,没有返回值数据类型,也没有void的修饰,方法名称和类名
 * 完全相同,如果不同就不能叫构造函数
 *
 * 注意:
 *  1、在你没有创建构造函数的时候,计算机默认的给你一个无参的构造函数,这时类的跳转会指向
 *     类名
 *  2、如果你有一个有参的构造函数,又想调用无参的构造函数那么就必须自己手动创建无参的构造函数
 *  3、有参构造函数的参数括号中表示的都是属性,我们要完成属性赋值的过程
 *  4、我们创建类的时候可以根据自己的需求定义多个构造函数,只要参数的个数是不同的,参数的类别是不同的,参数的顺序是不同的就可以了
 *     这个过程叫方法的重载
 *  5、如果你能够一次性对所有的属性进行赋值就使用有参构造函数,如果你只是对部分属性进行赋值就使用无参构造函数+set的方法
 *     如果你想要获取所有的值,那么就使用一个叫toString
 */
public class People{
    private String id;//编号
    private String name;//姓名
    private String sex;//性别
    private String address;//家庭地址
    private String phone;//手机号码
    private int age;//年龄

    /**
     * 没有参数的构造函数
     */
    public People(){

    }

    /**
     * 我们想要给一个对象赋值,需要给这个类的属性进行赋值.构造函数的参数就是创建对象的时候传过来的值
     * 然后赋值给属性类中的属性,成为属性值
     */
    public People(String id,String name,String sex,String address,String phone,int age){
        //等号右边是参数的值,参数的值来自于创建对象的时候传入的值
        //等号左边表示本类中的属性,因为两个名称都相同,所以我们在前面加了this
        //表示本类中的元素
        this.id = id;//将参数的值赋值到本类中的属性中
        this.name = name;
        this.sex = sex;
        this.address = address;
        this.phone = phone;
        this.age = age;
    }

    public People(String id,String name,String sex){
        this.id = id;//将参数的值赋值到本类中的属性中
        this.name = name;
        this.sex = sex;
    }

    //get:获取 获取到对象的属性值   无参数有返回值的方法   方法名:get属性名首字母大写
    public String getId(){
        return id;
    }

    //set:设置 给属性进行赋值      有参数无返回值的方法   方法名:set属性名首字母大写
    public void setId(String id){
        this.id = id;
    }

    public void print(){
        System.out.println("id = " + id + "\n" + "name = " +
                name + "\n" + "sex = " + sex + "\n" + "address = " + address + "\n" +
                "phone = " + phone + "\n" + "age = " + age);
    }


    @Override //当它重写父类的方法的时候
    public String toString() {
        return "People{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", phone='" + phone + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类
public class PeopleTest {
    public static void main(String[] args) {
        //类名 对象名 = new 构造函数名称();
        People p = new People("1001","张三","男","湖北省武汉市东湖高新区", "13233333333",23);
        System.out.println(p.toString());
        System.out.println("---------------------------------------");
        People p1 = new People();
        p1.setId("1002");
        System.out.println(p1.toString());
        System.out.println("---------------------------------------");
        People p2 = new People("1003","李四","男");
        System.out.println(p2.toString());
    }
}

//面向对象练习
/**
 * 定义一个学生类Student，包含三个属性姓名、年龄、性别。
 */
public class Student {
    private String name;//名字
    private int age;//年龄
    private String sex;//性别

    //使用构造函数给属性进行赋值
    public Student(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    //添加一个用来取出学生年龄的方法
    public int getAge(){
        return age;
    }

    //需要一个set方法来帮助修改姓名
    public void setName(String name){
        this.name = name;
    }

    //使用toString的方法将对象内容输出
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

/**
 *  创建三个学生对象存入ArrayList集合中
 *  A：遍历集合遍历输出。 -- for语句遍历
 *  B：求出年龄最大的学生，然后将该对象的姓名变为：王五
 */
public class StudentMethod {
    //创建一个集合
    //因为这个集合需要多个方法进行调用,所以我们将集合放在方法外面类里面,让其成为全局的
    //数据类型使用Student那么这个集合就只能存储student类型的元素,因为类也是引用数据类型
    ArrayList<Student> students = new ArrayList<Student>();
    Scanner scanner = new Scanner(System.in);

    //向集合中添加对象
    public void add (){
        System.out.println("请问你要添加几个学生信息进入数据库中:");
        int num = scanner.nextInt();
        for(int i = 1; i <= num; i++){
            System.out.println("请输入学生姓名:");
            String name = scanner.next();//张三
            System.out.println("请输入学生年龄:");
            int age = scanner.nextInt();//20
            System.out.println("请输入学生性别:");
            String sex = scanner.next();//男
            //创建对象,将其放在方法中,如果方法不执行就不创建,如果方法执行了,就创建对象
            Student s = new Student(name,age,sex);
            //将对象添加到集合中
            //集合名.add();
            students.add(s);
            System.out.println("你已经添加了:" + i + "个信息");
        }
    }

    //遍历信息
    public void print(){
        if(students.size() == 0){
            System.out.println("没有学生信息");
        }else{
            //遍历学生信息
            for(int i = 0; i < students.size(); i++){
                System.out.println(students.get(i));
            }
        }
    }

    //比较年龄将年龄最大的名字改成王五
    public void max(){
        //定义一个变量用来存储学生年龄的最大值
        int max = 0;
        //定义一个变量用来存储年龄最大的元素的下标
        int index = -1;
        //遍历元素信息
        for(int i = 0; i < students.size(); i++){
            //如果一个学生的年龄比最大值还大,就将它的年龄赋值为新的最大值
            //并且将这个学生在集合中所在的下标赋值到index变量中方便我们后面
            //查询元素
            //students:用来存储学生信息的集合
            //students.get(i):获取到指定下标的学生对象
            //students.get(i).getAge():获取到集合中指定下标的元素的对象的属性值是多少
            if(students.get(i).getAge() > max){
                max = students.get(i).getAge();
                index = i;
            }
        }
        students.get(index).setName("王五");
        //输出改完之后的信息进行验证
        System.out.println(students.get(index).toString());
    }
}

/**
* 测试类
 */
public class StudentWorkTest {
    public static void main(String[] args) {
        StudentMethod sm = new StudentMethod();
        System.out.println("----------添加学生信息----------");
        sm.add();
        System.out.println("----------遍历学生信息----------");
        sm.print();
        System.out.println("----------更改学生信息----------");
        sm.max();
    }
}

2. 员工管理系统案例

/**
 * 员工类
 *
 */
public class Emp {
    //工号
    private String eid;
    //姓名
    private String name;
    //性别
    private String sex;
    //年龄
    private int age;
    //工龄
    private int workYear;
    //工资
    private double salary;
    //部门
    private String dept;
    //电话
    private String phone;

    //alt + insert
    //无参构造函数 constructor 构造函数
    public Emp() {
    }

    //有参构造函数
    public Emp(String eid, String name, String sex, int age, int workYear, double salary, String dept, String phone) {
        this.eid = eid;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.workYear = workYear;
        this.salary = salary;
        this.dept = dept;
        this.phone = phone;
    }

    //get set方法
    public String getEid() {
        return eid;
    }

    public void setEid(String eid) {
        this.eid = eid;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public int getWorkYear() {
        return workYear;
    }

    public void setWorkYear(int workYear) {
        this.workYear = workYear;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getDept() {
        return dept;
    }

    public void setDept(String dept) {
        this.dept = dept;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    //toString方法

    @Override
    public String toString() {
        return "Emp{" +
                "eid='" + eid + '\'' +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", workYear=" + workYear +
                ", salary=" + salary +
                ", dept='" + dept + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

/**
* 处理员工相关逻辑的类
 */
public class EmpDao {
    //定义一个集合用来存储我们创建的对象
    //角色相当于我们后面要使用的数据库,用来存储对象相关的数据
    //这个容器什么时候加载?当我们创建这个类的对象的时候就会对这个类进行加载
    //这个容器是自动加载,其他的方法是手动调用之后执行的
    ArrayList<Emp> emps = new ArrayList<Emp>();
    Scanner scanner = new Scanner(System.in);
    //1、输入添加员工信息
    public void add(){
        //当我们对数据进行输入的时候,就相当于给前面的变量进行赋值了
        //赋值完成之后我们就将这个变量的信息放到对象的构造函数的参数
        //位置去,当调用了构造函数之后,就可以对属性进行赋值,就完成了
        //对象的创建
        System.out.println("请输入员工id");
        String eid = scanner.next();
        System.out.println("请输入姓名");
        String name = scanner.next();
        System.out.println("请输入性别");
        String sex = scanner.next();
        System.out.println("请输入年龄");
        int age = scanner.nextInt();
        System.out.println("请输入工龄");
        int workYear = scanner.nextInt();
        System.out.println("请输入工资");
        double salary = scanner.nextDouble();
        System.out.println("请输入部门");
        String dept = scanner.next();
        System.out.println("请输入电话");
        String phone = scanner.next();
        //将输入的值放在构造函数参数的部分
        Emp emp = new Emp(eid,name,sex,age,workYear,salary,dept,phone);
        //将我们创建好的对象放入到集合中去
        emps.add(emp);
    }
    //2、查询所有员工信息
    public void findAll(){
        for(int i = 0; i < emps.size(); i++){
            System.out.println(emps.get(i));
        }
        System.out.println("--------------------------------------------");
    }
    //3、根据部门查询员工信息
    public void findByDept(){
        System.out.println("3");
    }
    //4、查询某一个工资区间内的员工信息 工资最低值和最高值手动输入
    public void findSalary(){
        System.out.println("请输入你要查询工资的最小值:");
        double sMin = scanner.nextDouble();
        System.out.println("请输入你要查询工资的最大值:");
        double sMax = scanner.nextDouble();
        //循环对所有的元素进行遍历
        for(int i= 0; i < emps.size(); i++){
            if(emps.get(i).getSalary() >= sMin && emps.get(i).getSalary() <= sMax){
                System.out.println(emps.get(i));
            }
        }
    }
    //5、根据工龄查询员工信息
    public void findByWorkYear(){
        System.out.println("请输入你要查询的员工的工龄:");
    }
    //6、根据id删除员工信息
    public void deleteByEid(){
        System.out.println("6");
    }
    //7、根据部门删除员工信息
    public void deleteByDept(){
        System.out.println("7");
    }
    //8、根据工号更改员工部门或者薪资信息
    public void updateByEid(){
        System.out.println("8");
    }
    //9、根据工号查询员工信息
    public void findByEid(){
        System.out.println("9");
    }

    //当你的方法都是普通的方法,没有使用static进行修饰的时候,我们可以直接对本类中的其他的方法进行调用
    //方法和方法之间也可以相互调用,如果你需要将另外一个类中的方法进行执行和调用那么我们必须创建你要调
    //用的方法的类对象。如果方法和方法和方法之间执行的时候需要有值的传输,那么只需要给方法添加一个返回
    //值就可以了
    public void menu(){
        System.out.println("***********************************************");
        System.out.println("***************欢迎登录员工管理系统**************");
        System.out.println("***********************************************");
        System.out.println("1、输入添加员工信息");
        System.out.println("2、查询所有员工信息");
        System.out.println("3、根据部门查询员工信息");
        System.out.println("4、查询某一个工资区间内的员工信息");
        System.out.println("5、根据工龄查询员工信息");
        System.out.println("6、根据id删除员工信息");
        System.out.println("7、根据部门删除员工信息");
        System.out.println("8、根据工号更改员工部门或者薪资信息");
        System.out.println("9、根据工号查询员工信息");
        System.out.println("0、退出");
        System.out.println("***********************************************");
        System.out.println("你要执行哪个操作?");
        int num = scanner.nextInt();
        switch(num){
            case 1:
                add();
                //因为我们每次都要回到菜单,所以我们可以在这里调用当前的方法,但是一定要有方法的停止
                menu();
                break;
            case 2:
                findAll();
                menu();
                break;
            case 3:
                findByDept();
                menu();
                break;
            case 4:
                findSalary();
                menu();
                break;
            case 5:
                findByWorkYear();
                menu();
                break;
            case 6:
                deleteByEid();
                menu();
                break;
            case 7:
                deleteByDept();
                menu();
                break;
            case 8:
                updateByEid();
                menu();
                break;
            case 9:
                findByEid();
                menu();
                break;
            case 0:
                System.exit(0);//退出系统关闭虚拟机
                break;
                default:
                    System.out.println("你输入的信息有误,请重新输入:");
                    menu();
        }
    }
}

public class EmpTest {
  public static void main(String[] args) {
        EmpDao empDao = new EmpDao();
        empDao.menu();
    }
}

day_03

1. 类与类之间的关系

从表现形式上是完全相同的,都是一个类作为另外一个类的属性存在

组合关系:相对来说不是那么紧密

聚合关系:必须有另外一个类的参与才能完成

纵向关系:继承 extends 实现 implements

2.继承

继承的表现形式是:就是将元素的相同的内容抽取出来,放在一个类中,其余的类写自己独特具有的元素,然后继承于这个公共类。

子类能够继承父类中非私有的属性和方法,但是构造函数虽然是public修饰的,不能被子类继承。

因为父类的构造函数是用来创建对象的,如果子类能够继承父类的构造函数就相当于子类能够创建一个父类对象.

好处:一个父类可以有多个子类,所有共用的元素可以全部放在父类中,不需要重复的去写,并且子类也可以直接调用。

缺点:增加了代码之间的耦合性。

对于程序设计而言,我们要做到:高内聚,低耦合

耦合:类与类,元素与元素之间的关联性,比如如果父类中的方法被修改了,子类就必须接受这个修改之后的内容

重要提示:一个父类可以有多个子类,但是一个子类只能有一个父类

3.游离块

游离块是一种特殊的方法,和类属于一个级别,只要这个类被调用了,无论是否创建对象,是否调用构造函数进行对象的创建,都会执行这个游离块的内容

语法:{

内容

}

游离块的执行:当存放游离块的类被调用的时候,会在执行所有的内容执行之前先执行游离块的内容

1. static

意思是静态的, 但是凡是用static修饰的元素都代表全局的

如果一个方法是static修饰的,那么它要调用的方法或者成员变量也要是static修饰的,或者说你可以对其进行创建对象之后进行赋值。

如果一个方法是没有使用static修饰的普通方法,想要调用static修饰的成员变量或者成员方法是可以进行处理的。

属性:如果使用static进行属性的修饰,那么一旦这个元素被赋值了,后面所有的元素在使用的时候都是初始赋上去的值。其中如果有一个对象将静态属性的值改变了,那么后面的获取到的都不是最初始的值

调用静态的元素的时候,可以并且推荐:直接使用类名进行调用类名.属性名 = 赋值; 类名.方法名();

public class People {
//修饰成员变量(全局变量(属性))
//静态成员变量
static String name;
static int age;
//非静态成员变量
private String sex;
private String address;
static int num = 20;
public People(){
}
public People(String sex, String address) {
this.sex = sex;
this.address = address;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
}
public class PeopleTest {
public static void main(String[] args) {
People.name = "丁真";
People.age = 18;
People people = new People();
//people.setName("张三");
//people.setAge(20);
//非静态变量我们创建了对象进行了元素的赋值
people.setSex("男");
people.setAddress("北京");
System.out.println(people.num);
people.num += 20;
System.out.println(people.toString());
People.name = "李四";
People.age = 20;
People people1 = new People();
System.out.println(people1.toString());
System.out.println(people1.num);
People people2 = new People();
System.out.println(people2.toString());
}
}

静态方法:java中支持使用static进行修饰成员方法,就是静态方法。与它相对应的是没有使用static修饰的方法也就是普通方法。与静态的成员变量一样,这个方法也是属于类本身的,不是属于某一个对象的。静态成员方法不需要创建对象就可以直接调用,非静态成员方法就必须创建对象之后才能进行使用。静态的成员方法不能使用this和super关键字，也不能调用非静态的成员方法。

public class Student {
static String name;
static int age;
static String major;
String sex;
public static String print(){
return name + "今年" + age + "是" + major + "专业的学生";
}
public int add(){
int a = 10;
int b = 20;
return a + b;
}
public void m(){
name = "王五";
add();
print();
System.out.println("这是一个普通方法");
}
public static void main(String[] args) {
//Student.sex = "男";
Student.name = "张数";
Student.age = 18;
Student.major = "挖掘机";
System.out.println(Student.print());
//Student.add();
}
}
public class Student {
static String name;
static int age;
static String major;
String sex;
public static String print(){
return name + "今年" + age + "是" + major + "专业的学生";
}
public int add(){
int a = 10;
int b = 20;
return a + b;
}
public void m(){
name = "王五";
add();
print();
System.out.println("这是一个普通方法");
}
public static void main(String[] args) {
//Student.sex = "男";
Student.name = "张数";
Student.age = 18;
Student.major = "挖掘机";
System.out.println(Student.print());
//Student.add();
}
}

5.final

可以修饰:类:被final修饰的类不能被继承

属性:被final修饰的属性不能再被赋值,所以我们在定义这个属性的时候必须给其符初始值,因为不能被改变了.所以叫常量.整个单词的字母全部大写。

方法:被final修饰的方法不能被重写

day_04

day_09

一、可变长参数

/**
* 可变长参数:
* 一般用在对对象进行赋值或者接收到从前端传过来的信息上
* 因为用户提交的信息可能是不完全的,可能出现参数个数不同的情况
* 并且从前端传过来的信息都是String类型,所以我们可以使用一个可
* 变长的参数来对元素进行处理
* 当我们定义一个可变长参数的方法的时候,我们只要确定传入参数的数据类型
* 和方法需要的参数类型是一致,那么就可以传多个参数进来,并且在方法中
* 最终以数组的形式进行处理
* 可变长参数不能够在后面继续添加别的参数,因为在给参数进行赋值的过程中,我们
* 无法确定,哪个值是给参数的
* 当你定义方法的时候,方法参数列表中的值,是形式参数,我们叫形参
* 当你调用方法的时候,在方法括号中添加的参数叫实际参数,我们叫实参
*/
public class Demo_01 {
ArrayList<String> arrayList = new ArrayList<String>();
//固定参数的方法
public void m(int a,int b){
System.out.println(a + b);
}
public void find(String name,String price){
for(int i = 0; i < arrayList.size(); i++){
if(arrayList.get(i).equals(name) || arrayList.get(i).equals(price)){
System.out.println("------");
         }
     }
}
public void m(String... s){
System.out.println(Arrays.toString(s));
          }
public void m1(int... a){
int sum = 0;
for(int i = 0; i < a.length;i++){
sum += a[i];
       }
System.out.println("sum = " + sum);
     }
public void m2(double sum,int... a){
sum = 0;
for(int i = 0; i < a.length;i++){
sum += a[i];
       }
System.out.println("sum = " + sum);
    }
public void m3(int... a){
System.out.println(Arrays.toString(a));
 }
public static void main(String[] args) {
Demo_01 demo_01 = new Demo_01();
demo_01.m(100,200);
demo_01.m1(10,20,30,40,50,60,65);
demo_01.m2(35.5,32,33,34,35);
demo_01.m3(12,13);
Demo_01 demo_011 = new Demo_01();
demo_011.m("中","票","adsaf","vfdsbaniolufh");
     }
}
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@ToString
public class People {
private int id;
private String name;
private String sex;
private int age;
     }
public class PeopleDao {
ArrayList<People> people = new ArrayList<People>();
public void reg(String... arr){
int id = Integer.parseInt(arr[0]);
String name = arr[1];
String sex = arr[2];
int age = Integer.parseInt(arr[3]);
People p = new People(id,name,sex,age);
people.add(p);
      }
}

二、递归

/**
* 递归
* 概念:
* 方法直接或者间接的方式调用自己本身,这样的形式称为递归
* 递归的三要素:
* 1、要有边界条件,也就是停止递归的条件
* 2、有点像循环,递归前进段,每次都对条件做出改变,调用执行自己本身
* 3、要有递归返回段,要将程序执行的返回值返回(要是你在综合类项目中,自己调用方法
* 自己本身的话,只要给它进行停止,如果每次执行的内容相同,可以没有前进段和返回段,
* 如果想要计算重复计算之后的值,那么就需要将递归进行和返回段控制)
*/
public void find(){
System.out.println(people);
    }
public void findByAge(){
for(int i = 0; i < people.size(); i++){
if(people.get(i).getAge() == 21){
System.out.println(people.get(i).toString());
       }
    }
  }
}
public class PeopleTest {
public static void main(String[] args) {
PeopleDao pd1 = new PeopleDao();
pd1.reg("1","张三","男","18");
pd1.reg("2","张四","男","19");
pd1.reg("3","张五","男","21");
pd1.reg("4","张六","男","21");
pd1.find();
System.out.println("---------------------------");
pd1.findByAge();
   }
}

三、java内存分配

java程序运行的时候,需要在内存中分配空间,为了提高执行的效率,对内存空间进行了不同区域划分,因为每个区域都有特定的处理数据的方式和内存管理方式

栈:分为栈顶和栈底,所有的元素都是在栈顶进行操作的

比如:手枪弹夹一样,第一颗被压进去的子弹,最后一颗被打出来相当于入口和出口是相同的；特点:先进后出。

队列:一端进行插入操作,另外一端执行删除操作；像上车排队一样,所有的元素是在尾部添加进去,从队列头部出来；特点:先进先出。

public class Student {
private String name;
private int age;
    }
public class StudentTest {
public static void main(String[] args) {
//new出来的对象会存储在堆中,每个对象都会有一个地址
//student:对象名 引用
//=:赋值符号 指向
//new Student("王也",20):真正具有意义的应该是后面构造函数new出来的对象
Student student = new Student("王也",20);
//将student的地址赋值给student1,指向同一个地址
//多个引用指向同一个对象
Student student1 = student;
System.out.println(student == student1);
Student student2 = new Student("王也",20);
System.out.println(student == student2);
//一个引用多个对象
//如果之前已经产生过地址了,新的地址会将之前的地址覆盖
Student s = new Student();
s = new Student();
s = new Student();
   }
}

day_05

一、关于静态

静态变量:被static修饰的变量,是类变量

非静态变量:没有被static修饰的变量,叫实例变量 属性也是 方法中的局部变量也是

两者之间的区别:

对于静态变量在内存中只有一个拷贝,jvm(java虚拟机)只为静态变量分配一次内存,在类进行加载的过程中完成。

内存的分配,可以使用类名进行直接调用(比较方便).也可以通过对象名来进行访问。(但是不建议使用,因为会报警告)。静态属性是属于类的,所以属性是可以共享的。

对于非静态变量,每次在堆中创建一次对象,就会分配一个内存,非静态变量可以在内存中进行多次的拷贝,相互之间不影响。那么属性就是自己的.

静态方法和非静态方法

区别1:

static修饰的方法是静态方法(类方法)

没有使用static修饰的方法,是非静态方法(实例方法)

区别2:调用方式不同

静态方法可以并且建议直接使用类名进行调用

非静态方法必须创建对象之后才能使用

区别3:内部元素成分

静态方法中,只能访问静态的属性和方法.不能使用this和super关键字

非静态方法中,什么都可以调用,包括静态方法,也可以使用this和super

二、抽象类

1、什么是抽象类?就是使用abstract修饰的类

public abstract class 类名{

//全局变量

//普通方法

//构造函数

//抽象方法

}

2、特点:不能够直接使用抽象类创建对象,必须使用子类继承,并且实现父类(抽象类中)没有实现的方法

通过子类来创建对象。

3、什么情况下来定义抽象类？当类中有抽象方法的时候当子类继承一个抽象类的时候,不想实现抽象类中的抽象方法,则可以添加abstract变为抽象类；当一个类实现了一个接口,不能实现接口中所有的抽象方法的时候

4、抽象方法格式:

public abstract <返回值的数据类型> 方法名(参数列表);

没有方法体,也没有大括号

不能和private static final关键字一起使用

1、什么时候把类定义成抽象的?

(1)当不知道一个方法具体的算法的时候,就把这个方法定义成抽象的

(2)抽象方法必须定义在抽象类中

2、当编写一个类的时候,我们需要在类中定义方法,方法使用来描述这个类中有哪些功能,方法就是功能的具体实现。这些方法有具体的实现,但是当链各个类存在继承关系,某一个父类只知道这个子类应该包含一个功能,但是无法准确的去处理这个方法应该如何执行,那么就可以定义成抽象的。把父类定义成一个抽象类,让子类必须实现这个方法,但是具体的实现内容由子类自己决定

3、语法:

public abstract class 类名{
//全局变量
//普通方法
//构造函数
//抽象方法
}
public abstract 返回值的类型 方法名(参数列表);//只有方法的声明没有方法的具体实现
final:最终,final修饰的方法代表子类能不够重写这个方法
static:静态的方法,静态方法是属于整个类的
private:私有的方法,子类无法继承(子类根本看不到有这个方法),不能重写,而abstract和private一起使用的话,
abstract修饰的方法需要被子类重写,private修饰的方法子类又看不到,存在冲突

4、特点:

1、抽象类和抽象方法都是使用abstract进行修饰的

2、抽象类可以继承抽象类

3、抽象类也可以继承于一个普通的类

4、抽象类不可以被实例化(创建对象),因为实例化之后没有意义

5、只有实现父类(抽象类)中所有的抽象方法,其子类才可以进行实例化,否则子类也必须是一个抽象类

原因:之所以想要把一个类定义成抽象类,更多的是在编程的思想,使面向对象的操作更加简单

6、抽象类可以没有抽象方法,但是没有抽象方法的抽象类没有意义

7、抽象类中可以有构造函数,但是我们不去使用他,因为没有办法创建对象

5、抽象类一定是父类么?

是的,因为是在其他的类和功能中将其要实现的内容不断抽取出来的,一般把有共性和一些子类都有的方法放在抽象类中。但是子类中具体的实现是不一样的,这些方法在父类中就会被定义成抽象方法

6、抽象类中是否可以不定义抽象方法?

可以,但是一个没有抽象方法的抽象类,没有意义,就是不能创建对象罢了

三、接口

类:变量(静态变量,非静态变量)；常量；方法(静态方法,非静态方法)；构造函数

游离块(静态游离块) 内部类

抽象类:抽象方法；普通方法

构造函数(一般不用)

游离块(静态游离块)变量(静态变量,非静态变量)

常量 默认:public static final 数据类型 常量名;

抽象方法 默认:public abstract 返回值类型 方法名(参数列表);

从jdk1.8以后可以定义 静态方法和default方法,可以有实现(用得少)

接口:接口是功能的集合,同样也是引用数据类型,是比抽象更抽象的"类",不是使用class进行定义的

接口只描述应该具备的方法,没有方法的具体实现

接口是一种身份的象征

接口的定义:
public interface InterDemo {
public static final int AGE = 10;//常量
//可以定义抽象方法
public abstract void m();
//定义的抽象方法可以没有abstract修饰
public void m1();
//从jdk1.8以后
public static void m2(){
System.out.println("接口中static修饰的方法");
}
public default void m3(){
System.out.println("接口中default修饰的方法");
}
}
//接口的实现类,使用implements关键字进行处理
public class InterDemo_02 implements InterDemo{
@Override
public void m() {
System.out.println("接口中的第一个方法");
}
@Override
public void m1() {
System.out.println("接口中的第二个方法");
}
}
//接口中的defult修饰的方法以及实现类自己重写的方法都可以直接调用
//接口中的静态常量和接口中的静态方法,我们使用:接口.静态元素名称 来进行调用
public class Demo_test {
public static void main(String[] args) {
InterDemo_02 interDemo_02 = new InterDemo_02();
interDemo_02.m();
interDemo_02.m1();
InterDemo.m2();
System.out.println(InterDemo.AGE);
interDemo_02.m3();
}
}
文件和文件之间的关系:
1、接口和接口之间可以继承,并且是多继承
public interface C extends B,A{
}
2、接口和类之间
如果一个类实现了一个接口,就要实现接口中所有的抽象方法,如果不想实现,那么这个类就必须是抽象类,由子类
来进行实现。
如果一个类实现了一个接口,但是实现的接口还继承了别的接口,那么这个实现类要实现所有的抽象方法
接口不能够继承于一个普通的类,也不能继承于抽象类
特点:
1、接口中定义的变量是常量,值不可以被改变。
如果是基本数据类型的常量,值不可以被改变
如果是引用数据类型的常量,地址不可以被改变
2、接口中定义的方法可以省略去abstract不写
3、接口不可以创建对象
4、实现类必须实现接口中所有的抽象方法才能创建对象,如果不想实现,这个类就必须是抽象类
5、类与类之间:单继承 一个子类只能有一个父类
类与接口之间:多实现, 类 implements 接口1,接口2... 一个实现类可以实现多个接口
接口和接口之间:多继承, 一个接口可以有多个父接口
一个类继承于一个父类的同时还可以实现多个接口
为什么要定义接口?
原因:
接口可以解决单继承的问题
一个类可以同时实现多个父接口,父类中定义事物的基本功能,接口定义事务的扩展功能
好处:
接口的出现,降低了设备与设备之间的耦合性
接口的出现方便了后期的维护
一方是使用接口
一方是实现接口
接口和抽象类之间的区别:
相同点:
都位于继承的顶端,用于被其他的类实现或者继承
都不能创建对象
都可以定义抽象方法,子类都能够实现这些抽象方法

文件和文件之间的关系:

1、接口和接口之间可以继承,并且是多继承

public interface C extends B,A{
 }

2、接口和类之间

如果一个类实现了一个接口,就要实现接口中所有的抽象方法,如果不想实现,那么这个类就必须是抽象类,由子类来进行实现。

如果一个类实现了一个接口,但是实现的接口还继承了别的接口,那么这个实现类要实现所有的抽象方法

接口不能够继承于一个普通的类,也不能继承于抽象类

特点:

1、接口中定义的变量是常量,值不可以被改变。

如果是基本数据类型的常量,值不可以被改变

如果是引用数据类型的常量,地址不可以被改变

2、接口中定义的方法可以省略去abstract不写

3、接口不可以创建对象

4、实现类必须实现接口中所有的抽象方法才能创建对象,如果不想实现,这个类就必须是抽象类

5、类与类之间:单继承 一个子类只能有一个父类

类与接口之间:多实现, 类 implements 接口1,接口2... 一个实现类可以实现多个接口

接口和接口之间:多继承, 一个接口可以有多个父接口

一个类继承于一个父类的同时还可以实现多个接口

为什么要定义接口?

原因:接口可以解决单继承的问题,一个类可以同时实现多个父接口,父类中定义事物的基本功能,接口定义事务的扩展功能。

好处:接口的出现,降低了设备与设备之间的耦合性;接口的出现方便了后期的维护;

都位于继承的顶端,用于被其他的类实现或者继承都不能创建对象，都可以定义抽象方法,子类都能够实现这些抽象方法,一方是使用接口,一方是实现接口

接口和抽象类之间的区别:

相同点:都位于继承的顶端,用于被其他的类实现或者继承；；都不能创建对象

都可以定义抽象方法,子类都能够实现这些抽象方法。