java日记

基础

1.构造方法

作用：创建对象
功能：完成对象数据初始化
注意：建议同时给出无参和有参构造方法
标准类制作：

1. 成员变量

• 使用private修饰

2. 构造方法

• 提供一个无参构造方法
• 提供一个带多个参数的构造方法

3. 成员方法

• 提供每一个成员变量对应的getXxx（）/setXxx（）
• 提供一个显示对象信息的show（）

4. 创建对象并为其成员变量赋值的两种方式

• 无参构造方法创建对象后使用setXxx()赋值
• 使用带参构造方法直接创建带有属性值的对象

package com.javabase;
/*
    成员变量：使用 private修饰
    构造方法：（系统默认为每个没有手写带参构造方法的类，自动隐式提供一个无参构造方法
        但是如果手写了，系统不再自动提供无参构造方法）
        （构造方法名要与类名完全相同）
        1、提供一个无参构造方法——建议养成习惯每次都写上
        2、提供一个带多个参数的构造方法
    成员方法：提供get/set方法
        提供一个显示对象信息的show（）
 */
public class Solution {
 
    //定义两个成员变量，注意String大写，int小写
    //成员变量有默认初始值，存在堆中
    private  String name;
    private int age;
    //定义构造方法，注意修饰符和方法名
    //这两个构造方法用到了方法的重载（Overloading）：方法重载是让类以统一的方式处理不同类型数据的一种手段。
    //      调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。
    //      重载须注意2点：同一个类中、必须有所不同
    //补充：重写（0veriding）：也称覆写或覆盖。指子继承父类后对已存在的属性修改，或新增额外的属性。
    //      如果调用子类，但子类已经将对应属性进行修改。非要调用父类的话，可以用super关键字进行
    public Solution(){}
    public Solution(String name, int age){
        //this是为了解决局部变量隐藏成员变量的问题
        //this代表所在类的对象引用，方法被哪个对象调用，this就代表哪个对象
        this.name = name;
        this.age = age;
    }
    //成员方法set、get和show：
    public void setName(String name) {
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        //封装的安全性体现在可以对传入参数进行检查，提高安全性，如
        if(age < 0 || age > 120) {
            System.out.println("age must be no less than 0 and no more 120");
        }else {
            this.age = age;
        }
    }
    public int getAge(){
        return age;
    }
 
    public void show(){
        System.out.println(name + ", " + age);
    }
}
```java
package com.javabase;
/*
    创建对象并为其成员变量赋值的2中方式:
        1、无参构造方法创建对象后使用set赋值
        2、带参构造方法直接创建带有属性值的对象
 */
public class Test {
    //必须要在main函数下调用其他类，否则两个类都没有main会报错 cannot resolve symbol
    public static void main(String[] args) {
        Solution s1 = new Solution();
        s1.show();
 
        Solution s2 = new Solution();
        s2.setName("Jack");
        s2.setAge(18);
        s2.show();
 
        Solution s3 = new Solution("Mary", 16);
        s3.show();
    }
 
}

2.集合

特点：
集合提供一个存储空间可拿取的存储模型，存储的数据容量可以发生改变
ArrayList
array.remove(Object o)
array.remove(int index)
array.set(int index,E element)
array.get(int index)
array.size()

3.继承

this ：表示本类对象的引用
super ：标识父类存储空间的标识（表示父类对象的引用）
子类中所有的构造方法默认都会访问父类无参的构造方法

•  因为子类会继承父类中的数据，可能还会使用父类中的数据。所以，之类初始化之前，一定要先完成父类数据的初始化
   每一个子类构造方法的第一条语句默认都是：super（）
  

方法的重写与重载

• 方法重写的注意事项：
  1.私有方法不能被重写（父类私有成员子类不能继承）
  2.子类方法访问权限不能更低（public>default>private）
• 继承的注意事项：

1. java中类只支持单继承，不支持多继承
2. java中类支持多层继承

4.final static 多态

final修饰的特点：
修饰方法：表名该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能被赋值
修饰局部变量：

• 			基本类型：基本类型的数据值不能改变
  			引用类型：引用类型的地址值不能改变，地址里面的内容可以改变
  			修饰类：表明该类是最终类，不能被继承
  

1.关于静态的问题：

•   静态方法属于全局方法，当静态方法第一次被访问的时候，就将常驻内存直到整个系统被销毁；
    而非静态方法则与类有关，只有该方法所在的类被实例化之后，该方法才能被访问，类被销毁的同时方法也被销毁。
    生命周期的不同决定了它们的调用方式的不同，静态方法使用（类名.方法名）来调用，而非静态方法则需要（new 类名().方法名）来调用。
  

多态：
1.多态中成员访问特点：

•   成员变量：编译看左边，执行看左边
    成员方法：编译看左边，执行看右边（成员方法有重写，而成员变量没有）
  

2.好处与弊端：

•   好处：提高了程序的可扩展性（定义方法时，使用父类型作为参数，将来使用时，使用具体的子类型参与操作）
    弊端：不能使用子类中的特有功能
  

3.多态中的转型(实现访问子类中的特有功能)：

•   向上转型（从子到父）：父类引用指向子类对象 Animal a = new Cat();
    向下转型（从父到子）：父类引用转为子类对象 Cat c =(Cat)a;
  

5.抽象类

1.抽象类中可以没有抽象方法，有抽象方法必须是抽象类
2.抽象类的子类，必须是抽象类或者实现抽象类中的所有抽象方法
3.抽象类不能直接实例化，可以有构造方法初始化对象，参照多态的方式，通过子类对象实例化（抽象类多态）

6.接口

接口实例化：通过实现类对象实例化（接口多态）
多态的形式：具体类多态，抽象类多态，接口多态
多态前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
接口的成员特点：
1.成员变量：

•   只能是常量
    默认修饰符：public static final
  

  2.构造方法：

•   接口没有构造方法，因为接口主要是对行为进行抽象，是没有具体存在
    已给类如果没有父类，默认继承自Object类
  

  3.成员方法：

•   只能是抽象方法
    默认修饰符：public abstract
  

  4.类与接口的关系：

•  类与类的关系：继承关系，单继承，可以多层继承
   类与接口的关系：实现关系，单实现，可以多实现，还可以继承一个类的同时实现多个接口
   接口与接口的关系：继承关系，单继承，也可以多继承
  

7.形参和返回值

1.类名作为形参和返回值

•   方法的形参是类名，其实需要的是该类的对象
    方法的返回值是类名，其实返回的是该类的对象
  

2.抽象类名作为形参和返回值

•   方法的形参是类名，其实需要的是该抽象类的子类对象
    方法的返回值是类名，其实返回的是该抽象类的子类对象
  

3. 接口类名作为形参和返回值

•  	方法的形参是类名，其实需要的是该接口类的实现类对象
   	方法的返回值是类名，其实返回的是该接口类的实现类对象
  

8.内部类

1. 内部类与外部类

•   内部类可以直接访问外部类
    外部类需要创建对象，才能访问内部类
  

2.成员内部类，局部内部类，匿名内部类

•   成员内部类创建对象：外部类名.内部类名 对象名 = 外部对象.内部对象；
    范例：Outer.Inner oi  = new Outer().new Inner();
    通常成员内部类为private class，需要在外部类创建访问内部类的方法，在其他类中创建外部类对象，调用访问内部类的方法即可。
    局部内部类（方法中定义的类）：在方法中创建对象访问内部类，在其他类中创建外部类对象，调用访问内部类的方法即可。
    匿名内部类（本质是一个继承了该类或者实现了该接口的子类匿名对象）
  

9.异常

java异常处理机制

10.Collection集合

Collection集合

11.泛型

泛型

12.IO流

java——IO流