java复习回顾
文章目录
- 0 开发工具
- 1. 对象和类、三大特性
- 2. 成员/实例变量和实例变量（this关键字）
- 3. 方法重载overload
- 4. 构造方法和this关键字
- 5. 继承
- 6. 访问修饰符
- 7. 方法重写
- 8. 继承下的构造执行
- 9. 多态
-
- 9.1 向上转型
- 9.2 向下转型
- 9.3 多态的应用
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
有以下规则和特点：
- 子类方法的访问权限可以比父类大
- 子类方法的返回值类型可以和父类一致，也可以是父类返回类型的子类
- 方法名一定要完全一样
- 参数列表也必须和父类完全一样（否则就成方法重载了）
- 子类重写父方法后，优先执行子类方法。若想要执行父类中被重写 的方法，使用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){//多态的应用二，返回的是Pet
if(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("猫咪在吃鱼");
}
}