0 开发工具

Maven是进行包管理的工具，只需要声明一些配置，程序就可以自动下载所依赖的包。其配置文件在本机电脑~\.m2\settings.xml中，settings.xml里面声明了依赖包存放的位置，也可以在里面声明下载依赖包的国内镜像地址。

idea中自带了jdk，无需额外安装。
Git可用来进行版本控制

1. 对象和类、三大特性

面向对象的思想object oriented programming：一切皆对象，对象由属性和方法构成。
类相当于一个模板，对象是由类创建出来的，每个对象都是类的一个实例，创建对象的过程也称为实例化。

封装：把一些对象的共同属性、方法抽象出来，合理的封装，抽象成类。
继承：子类享有父类的属性和方法，并且还存在一定的属性和方法的扩展
多态：有两种意义的多态。一种是操作名称的多态，即有多个操作具有相同的名字，但这些操作所接收的参数类型必须不同。 另一种多态是和继承有关的多态，是指同一个操作被不同类型对象调用时可能产生不同的行为。

2. 成员/实例变量和实例变量（this关键字）

成员变量也叫实例变量。

// 该例子展示了实例/成员变量、局部变量的作用范围
// 以及this关键字的使用：this指向当前对象
public class Dog {String name;public Dog(){ // 构造方法name="汪汪";}public void eat(){String name="局部变量汪汪";System.out.println(name+"在吃东西");//name=局部变量汪汪System.out.println(this.name+"在吃东西");//name=汪汪}public void sleep(){System.out.println(name+"在睡觉");//name=汪汪}public String getName() {return name; //name=汪汪}
}

3. 方法重载overload

方法重载overload：一个类中定义多个具有相同名字的方法，具体执行哪个，由传入的参数决定。即方法名字相同，参数列表不同（类型、个数、顺序），与返回值类型、访问修饰符无关。
System.out.println();是一个经典的重载方法。

//方法重载举例
public class ClassTest {public void test(int a){}public void test(String a){}public void test(int a,String b){}public void test(String a,int b){}
}

4. 构造方法和this关键字

构造方法：类中的特殊方法，主要用于创建对象。

• 名称与类名相同
• 没有返回类型
• 创建对象时，出发构造方法
• 编译器默认执行一个无参的构造方法
• 构造方法也可以重载，遵循重载规则

public class ThisTest {public static void main(String[] args) {ThisDog dog=new ThisDog("汪汪",5,"公");System.out.println(dog.name+"---"+dog.age+"---"+dog.sex);}
}

public class ThisDog {String name;int age;String sex;public ThisDog(String name,int age){this.name=name;this.age=age;}public ThisDog(String name,int age,String sex){this(name,age); //this调用重载的构造方法只能放在第一行this.sex=sex;}
}

5. 继承

语法：class子类 extends 父类{ } //定义子类时，显式继承父类。所有的类默认都继承Object
应用：子类可以使用父类中的属性和方法，也可定义自己独有的属性和方法。
优势：提高了代码的复用性和可扩展性。
特点：单继承（一个子类只能有一个直接父类）；多重继承（类之间可以多级继承，如C类可以继承A类、B类中所有的属性和方法）

注意：父类的私有属性可以被继承但不能被直接访问（可借助其他工具观察内存分布，可知父类的私有属性可以被继承。父类的私有属性可通过get、set方法访问）。
当父类和子类具有相同的属性时，使用super和this关键字区分。

父类的私有属性可通过get、set方法访问

public class A {private int a;public void setA(int a) {this.a = a;}public int getA() {return a;}public void show() {System.out.println("父类的show方法");}
}

public class B extends A{public B(){setA(1);}public void show(){System.out.println(getA()+" 子类的show方法");}
}

public class Test {public static void main(String[] args) {B b=new B();b.show();}
}
//输出： 1 子类的show方法

6. 访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

默认访问修饰符-不使用任何关键字
如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符，那么它们就默认具有默认访问修饰符。

默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问。

7. 方法重写

前提A是父类，B extends A
有以下规则和特点：

1. 子类方法的访问权限可以比父类大
2. 子类方法的返回值类型可以和父类一致，也可以是父类返回类型的子类
3. 方法名一定要完全一样
4. 参数列表也必须和父类完全一样（否则就成方法重载了）
5. 子类重写父方法后，优先执行子类方法。若想要执行父类中被重写 的方法，使用super关键字

//父类A中的show方法
protected A show() {System.out.println("父类的show方法");return null;
}

//子类B中的show方法，B extends A，public > protected，B < A
public B show(){super.show();System.out.println("子类的show方法");return null;
}

public class Test {public static void main(String[] args) {B b=new B();b.show();}
}
/*输出：
父类的show方法
子类的show方法
*/

8. 继承下的构造执行

要想构造子类，必先调用父类构造方法，但并未构建一个父类对象，构建的是子类对象

// 无参构造方法
package example05;public class Test {public static void main(String[] args) {new C();}
}
class A{public A(){System.out.println("A的构造方法");}
}
class B extends A{public B(){System.out.println("B的构造方法");}
}
class C extends B{public C(){System.out.println("C的构造方法");}
}
//output:
//A的构造方法
//B的构造方法
//C的构造方法

要想构造子类，必先调用父类构造方法，但并未构建一个父类对象，构建的是子类对象。其空间分布如下：
其判断具体见下面代码中的注释掉的输出，均为true。
一个子类对象可以是一个父类类型，但一个父类对象不能是一个子类类型。如b是B的一个对象，c是C的一个对象，b instanceof C=false，c instanceof B=true

//        System.out.println(this instanceof B);// true，一个子类类型可以是一个父类类型
//        System.out.println(this instanceof C);// true

// 有参构造方法
package example06;public class Test {public static void main(String[] args) {C c=new C(7,8,9);System.out.println(c.a+"---"+c.b+"---"+c.c);}
}
class A{int a=1;public A(int a){this.a=a;System.out.println("A的构造方法");}
}
class B extends A{int b=2;public B(int a,int b){super(a);this.b=b;System.out.println("B的构造方法");
//        System.out.println(this instanceof B);// true
//        System.out.println(this instanceof C);// true}
}
class C extends B{int c=3;public C(int a,int b,int c){super(a,b);this.c=c;System.out.println("C的构造方法");}
}
//输出
//A的构造方法
//B的构造方法
//C的构造方法
//7---8---9

9. 多态

以下所举例子，均以A是父类，B extends A，C extends B为前提。

9.1 向上转型

父类引用指向子类对象，从而形成多态。
父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。
A a=new B(); A a是父类引用（引用类型），new B()产生了一个子类对象（对象类型），a只能调用A中的方法/属性，不能调用B中的方法/属性。也就是a.属性/方法()必须在类A中存在。
若子类B没有重写A的show方法，输出父类A的show方法。若调用a.showB()会报错，因为父类A中并没有showB方法

package example06;public class Test {public static void main(String[] args) {A a=new B();a.show();
//        a.showB(); //报错}
}
class A{public void show(){System.out.println("父类A的show方法");}
}class B extends A{public void show(){System.out.println("子类B的show方法");}public void showB(){System.out.println("子类B的showB方法");}
}//输出：子类B的show方法

9.2 向下转型

将父类引用中的真实子类对象，强制转换为子类本身对象，称为向下转型。

A a=new B();
B b=(B) a;//强制类型转换

向下转型前，应判断引用中的对象的真实类型（使用instanceof来判断），保证类型转换的正确性。

9.3 多态的应用

应用一：使用父类作为方法形参实现多态，使方法参数的类型更广泛。
应用二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

package example08;public class Person {public void feed(Pet pet){//多态的应用一，Pet作为方法形参pet.eat();}public Pet getPet(String type){//多态的应用二，返回的是Petif(type.equals("dog")){return new Dog();}else{return new Cat();}}public static void main(String[] args) {Person person=new Person();Pet pet=person.getPet("dog");person.feed(pet);//多态的应用二person.feed(new Cat());//多态的应用一，可以改成new别的，如Dog}}
class Pet{public void eat(){System.out.println("在吃东西");}
}class Dog extends Pet{public void eat(){System.out.println("狗狗在啃骨头");}
}
class Cat extends Pet{public void eat(){System.out.println("猫咪在吃鱼");}
}