idea常用快捷键

  1. Ctrl + Alt + L 格式化

  2. Shift + F10 编译运行

  3. Alt + Insert 插入构造器

  4. Ctrl + H 显示继承关系

  5. Alt+Enter new完对象后可以直接分配变量名

idea 断点调试

  1. 跳入（F7): 跳入方法内（可以查看JDK原码）
  2. 跳过（F8): 逐行执行代码
  3. 跳出（shift+F8)：跳出方法
  4. 继续（F9)：跳到下一个断点

JUnit

JUnit是一个Java语言的单元测试框架，多数Java的开发环境已经继承了JUnit作为单元测试工具。

使用方式

​ 如果在编写主方法时添加了很多非静态的方法，则在逐个测试方法时需要在main()函数中挨个new出来，再逐个测试。这样做非常的麻烦，可以点击Alt + Enter安装JUnit框架，在需要测试的方法上加@Test标识，则该方法前面会出现绿色的运行按钮，这样不需要在main()函数中声明也可以快速执行方法。

public class Test{
    public static void main(String[] args){
        // new Test().m1();
        // new Test().m2();
    }
    
    @Test
    public void m1(){
        System.out.println("m1 is Testing");
    }
    
    @Test
    public void m2(){
        System.out.println("m1 is Testing");
    }
}

包(package)

包本质就是文件夹，创建不同的文件夹/目录来保存类文件。

作用

  1. 区分相同名字的类
  2. 更好的管理类
  3. 控制访问范围

使用

package 文件夹名.文件夹名…

在import上面写，使用idea时会自动添加。

访问修饰符

访问级别 访问控制修饰符 同类 同包 子类 不同包
公开 public √ √ √ √
受保护 protected √ √ √ ×
默认 无修饰符 √ √ × ×
私有 private √ × × ×

面向对象

封装、继承、多态

封装

​ 封装（encapsulation）就是把抽象出的属性和方法封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作[方法]，才能对数据进行操作。

实现步骤

  1. 将属性私有化

  2. 提供一个public的类set方法，用于对属性判断并赋值

  3. 提供一个public的类get方法，用于获取属性的值

继承

​ 当两个类的属性和方法有很多相同部分时，需要继承。即当多个类存在相同的属性和方法时，可以抽象出父类，在父类中定义这些相同的属性和方法，子类不需要重新定义这些属性和方法，只需要通过extends来声明继承。

优点

  1. 提高代码复用性
  2. 提高代码扩展性和可维护性

用法

class 子类 extends 父类{
	// 类体
}

性质

  1. 子类自动拥有父类定义的属性和方法
  2. 父类又叫超类，基类
  3. 子类又叫派生类
  4. 一个子类只能有一个直接父类（只能继承一个类），但是可以有很多祖宗类（父类又继承了一个超类，那个超类又继承了一个超类……)
  5. 子类必须调用父类的构造器， 完成父类的初始化
  6. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器。如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作
  7. super和this都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
  8. java所有类都是Object类的子类,Object是所有类的基类

多态

方法或对象具有多种形态,多态是建立在封装和继承基础之上的。

具体体现

  1. 方法的多态（重载和重写等）
  2. 对象的多态
    • 一个对象的编译类型和运行类型可以不一致
    • 编译类型在定义对象时即确定，运行类型可以变化。

对象的向上转型

父类的引用指向子类的对象

特点

  1. 可以调用父类中所有成员（遵守访问权限）

  2. 不能调用子类特有的方法（编译阶段能调用哪些成员，由编译类型决定）

  3. 最终运行效果看子类(运行类型)的具体实现，即调用方法时，按照从子类（运行类型）开始查找方法。

对象的向下转型

父类对象转换成子类对象。与向上转型不同，向下转型是不安全的

演示

public class A {
}

public class B extends A {}
public class C extends A {}

public class Main{
    public static void main(String[] args){
        // 向上转型
        A a = new B(); // 编译类型是A，运行类型是B
        a = new C(); // 编译类型是A，运行类型是C
        
        // 向下转型
        A a = new A();
        B b = (B)a;
    }
}

动态绑定

  1. 当调用对象方法时，该方法会和该对象的内存地址（运行类型）绑定

  2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

补充：instanceOf是比较操作符，用于判断对象的运行类型是否为某类型或某类型的子类型。

类的五大成员

属性、方法、构造器、代码块、内部类

属性/成员变量/字段

就是类中定义的变量。

public class Employee{
	public String name;
	public int age;
	private int salary;
	
	......
}

注意事项

  1. 属性的定义方法用变量：访问修饰符 属性类型 属性名
  2. 属性如果不赋值会使用默认值。byte、short、int、long赋0，float、double赋0.0，char赋\u0000，boolean赋false，String赋null。

方法/成员方法

就是类中定义的函数。

public class Employee{
	......
	public void work(){
		System.out.println("工作");
	}
    public static int getSalary(){
        return this.salary;
    }
}

方法重载(overload)

java中允许同一个类中，多个同名方法的存在，但要求形参不一致(变量类型或者变量数量)

  1. 减轻了起名的麻烦
  2. 减轻了记名的麻烦
class MyCalculator{
    public int calculator(int n1,int n2){
        int res = n1 + n2;
        return res;
    }
    public double calculator(int n1,double n2){
        double res = n1 + n2;
        return res;
    }
    public double calculator(double n1,int n2){
        double res = n1 + n2;
        return res;
    }
    public int calculator(int n1,int n2,int n3){
        int res = n1 + n2 + n3;
        return res;
    }
}

方法重写(override)

  1. 即在子类中重新写一遍父类中的方法，需要和父类方法的参数，名称完全一样

  2. 返回类型要么一样，要么是父类返回类型的子类，比如Object -> String

  3. 子类方法的访问权限必须大于等于父类方法

方法重载与重写的区别

名称访问 范围 方法名 形参 返回类型 修饰符
重载 本类 相同 类型、个数或者顺序至少有一个不同 随意 随意
重写 protected 相同 相同 一致或子类 大于等于父类

构造器

构造器是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。

特点

  1. 方法名和类名相同
  2. 没有返回值
  3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化
  4. 如果一个类不写构造器，则默认会有一个无参构造器
  5. 构造器的调用自动完成

使用

[访问修饰符] 方法名(形参列表){ 
     方法体;
}

接下来见java基础入门（二）