华清远见-重庆中心-JAVA面向对象阶段技术总结

方法

概念

一段独立的代码，能完成一件事情，可以被重复调用。

方法定义

[修饰符] 返回值类型 方法名([参数列表]){
    //方法体
}

1. 返回值类型、方法名和参数列表(小括号中的内容)是组成方法的三要素
2. 返回值类型可以是任意数据类型(原始类型/引用类型)
3. 小括号中的内容称为参数列表只需写参数类型和参数名，多个参数用逗号隔开。可以没有参数，但必须要有小括号
4. 访问修饰符可以不写，会有默认的修饰符(public)
5. 不同的返回值类型，要在方法体中返回(return)对应类型的结果，如果没有返回值，用void
6. 形参：方法定义中的参数。实参：方法调用中的参数。

方法调用

1.直接调用

方法在同一个类中，方法a()可以直接调用方法b()

public class Ran {
    public void a(){

    }
    public void b(){
        //调用本类中的另一个方法
        a();
    }
}

2.通过对象调用方法

可以在本类中通过对象调用本类中的方法（除构造方法），也可以在不同的类中创建对象调用该对象类中的方法（除构造方法）。

//创建一个Random类的对象rd
Random rd = new Random();
//生成[0,10)范围内的随机数
int num = rd.nextInt(10);

3.通过类调用方法

类中的方法是 被 static 关键字修饰的静态方法时 ，调用时， 直接通过类名调用 。

可以在本类中调用，也可以在其他类中调用

public class Ran{
public static void main(String[] args){
        //Math类的使用
        //Math类是一个数学工具类，包含了很多数学计算相关的方法
        //Math类中的方法都是被static修饰的静态方法，调用时直接通过Math类名访问
        //求绝对值
        int res = Math.abs(-5);
        System.out.println(res);
    }
}

方法的分类

1.无参数无返回值

void printHello(){
    //一般是写一些输出语句
    System.out.println("hello world");
}

2.有参数无返回值

void printA(int a){
    System.out.println(a);
}

3.无参数有返回值

int renA(){
    int a=2;
    return a;
}

4.有参数有返回值

int max(int a,int b){
    //返回最大值
    if(a<=b){
        return b;//不会在往下执行
    }
    return a;
}

构造方法

概念

构造方法是一个特殊的方法，没有返回值，方法名和类名一致（大小写完全一样）。

每个类在定义时，都有一个默认隐藏的无参数的构造方法，在创建对象时调用。

构造方法通常用于初始化成员变量。

public class Test{
    //这就是无参数的构造方法，默认就会存在，不过是隐藏了
    public Test(){
    }
}
和
public class Test{
    int a;
    //这就是有参数的构造方法
    public Test(int a){
        this.a=a;
    }
}

特点

1. 构造方法没有返回值(没有返回值这一部分，不是void)，构造方法名必须和类名相同
2. 每个类默认有一个隐藏无参数的构造方法，方法体中没有内容，用于创建无参数的对象
3. 如果自己写了有参数的构造方法，默认无参数的构造方法就会失效。如果想要同时拥有带参数和不带参数的构造方法，就需要把它们都写出来
4. 构造方法可以限制创建对象时的参数
5. 构造方法不能通过“.”操作符访问，只能通过new关键字创建对象时自动调用，所以构造方法通常用于初始化成员变量

方法总结

1. 无返回值的方法，返回值部分要写成void
2. 有返回值的方法，方法体中必须要写上return，且要在return后写上对应返回值类型的数据
3. 没有返回值的方法体中，也可以使用return关键字，但后面不能有值。只要出现return关键字，就不再执行后续代码
4. 有返回值的方法在调用时，需要接收返回的数据才能使用该数据
5. 方法定义时的参数称为形式参数，简称为形参，方便在方法体中使用。方法调用时传递的值称为实际参数，简称为实参，只需要保证满足形参的数据类型即可，与形参名无关

面向对象

类

现实生活中的一类具有共同属性和行为的事物的抽象

属性通过成员变量体现

行为通过成员方法体现

类的定义

[修饰符] class 类名{
    //成员变量
    //成员方法
}

对象 

对象的创建和使用

/*类名 对象名 = new 类名();
//使用成员变量
对象名.成员变量名
//使用成员方法
对象名.成员方法名()*/

class A{
    //成员变量
    private int a;
    //成员方法
    public void useA(){
        System.out.println(a);
    }
    //主方法
    public static void main(String[] args){
        //创建对象
        A hp = new A();
         //使用成员方法
        hp.useA();
    }


}

成员变量和局部变量 

成员变量	局部变量	区别
类中方法外	方法内或者方法声明上	类中位置不同
堆内存	栈内存	内存中位置不同
有默认的初始值	没有默认初始值，必须先定义，赋值，才能使用	初始值不同
随着对象的存在而存在，消失而消失	随着方法的调用而存在，方法调用完毕而消失	生命周期不同

封装

使用 private 关键字对属性进行修饰。再对外提供一组公开的 get/set 方法用于对该属性读取或赋值。 可以防止除自身类之外的地方对该属性就行访问。这样做可以保护关键属性，隐藏类内部的实现细节。

public class Player {
   
    private String name;//姓名
    private int age;//年龄
    private String sex;//性别

    //创建玩家类的getter和setter方法，用于获取和赋值
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

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

创建对象后，无法通过对象名.访问属性，只能通过对象名.get/set方法  

public class GameMain {
    public static void main(String[] args) {
        Player player = new Player();
        player.setName("ran");
        player.setSex("男");
        player.setAge(12);
        System.out.println("姓名："+player.getName()+
                "性别："+player.getSex()+
                "年龄："+player.getAge());
}}

继承

使用关键字extents，可以使得子类具有父类的属性和方法，还可以在子类中重新定义、追加属性和方法。语法：public class 子类名 extends 父类名{}

继承后，子类可以访问父类中非私有(没有被private修饰的内容)的属性和方法。

public class Father{
    public Father(){
        fun();
}
    public void fun(){
        System.out.println("父类中的普通方法");
    }
}

public class Son extends Father{
    public Son(){
        fun();
    }
    public void fun(){
        System.out.println("子类中的普通方法");
    }
}
public class Test{
public static void main(String[] args){
    //1.创建父类对象，调用父类中的无参构造方法
    //2.无参构造方法中会调用fun()方法，输出“父类中的普通方法”
    new Father();
    //1.创建无参子类对象，先调用父类中对应的无参构造方法
    //2.父类中无参构造会调用fun()方法，实际要执行子类重写后的fun()方法，输出“子类中
    的普通方法”
    //3.执行子类中的无参构造，调用重写后的fun()方法，输出“子类中的普通方法”
    new Son();
        //和前面的对象是父类和子类无关
    }
}
//最终输出
父类中的普通方法
子类中的普通方法

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中的无参的构造方法      why？

1. 因为子类会继承父类中的数据，可能还会使用父类的数据，所有子类初始化之前，一定要先完成父类数据的初始化。
2. 每一个子类构造方法的第一语句默认都是：super();

如果父类中没有无参构造方法，只有带参构造方法，该怎么办？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 在父类中自己提供一个无参构造方法

多态

多态就是子类的对象指向父类的引用 ( 子类对象使用父类变量接收，即向上转型 ) 。

父类 变量 = new 子类 ();

public class Main{
public static void main(String[] args){
Son son = new Son();
//这就是多态的体现
//子类的对象，可以使用父类的变量保存
Father father = new Son();
}
}

多态的前提和体现

1. 有继承/实现关系
2. 有方法重写
3. 有父类引用指向子类对象

抽象类和抽象方法

使用关键字abstract 

//抽象类
public abstract class 类名{}

//抽象方法
public abstract void 方法名();

抽象类不能实例化。但是抽象类如何实例化呢？

• 参考多态的方式，通过子类对象实例化。（抽象类多态）

抽象类的子类

• 要么重写抽象类中的所有抽象方法
• 要么本身就是抽象类

接口

接口用关键字interface修饰；类实现接口用implements表示。

//接口
public interface 接口名{}
//类实现接口
public class 类名 implements 接口名{}

接口不能实例化。接口如何实例化？

• 参考多态的方式，通过实现类对象实例化。（接口多态）

接口和抽象类的区别

• 抽象类有变量和常量，有构造方法，有抽象方法，也有非抽象方法
• 接口只有常量，有抽象方法
• 抽象类是对类抽象，包括属性和行为
• 接口是对行为抽象，主要是行为
• 抽象类是对事物的抽象，而接口是对行为的抽象
• 类与类是继承关系，单继承，可以多层继承
• 类与接口是实现关系，可以单实现，也可以多实现
• 接口和接口是继承关系 ，单继承，多继承

this和super

• this：本类对象引用
• super：父类对象的引用

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量 (访问本类成员变量)	this(...) (访问本类构造方法)	this.成员方法(...) 访问本类成员方法
super	super.成员变量 (访问父类成员变量)	this(...) (访问父类构造方法)	this.成员方法(...) 访问父类成员方法