类与对象
基础概念
类：一类事物，比较概括性（动物）
对象：类的实例，具体的某样事物（猫）
属性：类的成员变量，表示某事物所具有的特征（性别）
方法：对象可以做出的一些行为，是语句的集合，为了完成某件事情而存在（抓老鼠）
方法定义时编写的参数，我们一般称为形式参数，而调用方法实际传入的参数，我们称为实际参数。
静态变量：静态的内容，我们可以理解为是属于这个类的，也可以理解为是所有对象共享的内容。我们通过使用static关键字来声明一个变量或一个方法为静态的，一旦被声明为静态，那么通过这个类创建的所有对象，操作的都是同一个目标，也就是说，对象再多，也只有这一个静态的变量或方法。一个对象改变了静态变量的值，那么其他的对象读取的就是被改变的值。
代码实现
创建类->定义类->创建对象
public class Person {
String name;
int age;
String sex;
}
public class Main {
public static void main(String[] args) {
new Person();
}
}
使用对象
public class Main {
public static void main(String[] args) {
new Person();
Person p1 = new Person();
//此处p1存放的是对象的引用，而非本体，可通过对象的引用来间接操作对象
Person p2 = p1;
//p2赋值p1，仅传递对象的引用，而非对象的复制，p1和p2指向同一对象
System.out.println(p1 == p2);
}
}
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.name = "Alice"; //访问对象的属性，需要使用.运算符
System.out.println(p.name);
}
}
Alice
public static void main(String[] args) {
Person p = null; //null是一个特殊的值，它表示空，也就是不引用任何的对象
p.name = "小红"; //我任性，就是要操作
System.out.println(p.name);
}
空指针异常:操作一个值为null的变量导致出现错误
public static void main(String[] args) {
Person p = new Person();
System.out.println("name = "+p.name);
System.out.println("age = "+p.age);
System.out.println("sex = "+p.sex);
}
//直接创建对象，那么对象的属性都会存在初始值，如果是基本类型，那么默认是统一为0（如果是boolean的话，默认值为false）如果是引用类型，那么默认是null
方法的调用
public class Person {
String name;
int age;
String sex;
void hello(){
System.out.println("我叫 "+name+" 今年 "+age+" 岁了！");
}
int sum(int a, int b){
int c = a + b;
return c;
}
}
public class Main {
public static void main(String[] args) {
Person p = new Person();
p.name = "Alice"; //访问对象的属性，需要使用.运算符
p.age = 21;
int result = p.sum(10,20);
System.out.println(result);
p.hello(); //只需要使用.运算符，就可以执行定义好的方法
}
}
30
我叫 Alice 今年 21 岁了！
方法进阶使用
//在方法中访问到当前对象的属性，那么可以使用this关键字，来明确表示当前类的示例对象本身
void setName(String name){
this.name = name; //让当前对象的name变量值等于参数传入的值
}
//如果方法内没有变量出现重名的情况，那么默认情况下可以不使用this关键字来明确表示当前对象
String getName(){
return name; //没有使用this，但是当前作用域下只有对象属性的name变量，所以说直接就使用了
}
方法的重载
//一个类中可以包含多个同名的方法，但是需要的形式参数不一样，方法的返回类型，可以相同，也可以不同，但是仅返回类型不同，是不允许的！
int sum(int a,int b) {
return a + b;
}
double sum(double a,double b) {
return a + b;
}
public class Main {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.sum(1,2));
System.out.println(p.sum(1.2,1));
}
}
3
2.2
递归调用
void test(){
test();
}
//计算从1加到n的和
int test(int n){
if(n == 0) return 0;
return test(n - 1) + n; //返回的结果是下一层返回的结果+当前这一层的n
}
构造方法
//要在对象创建时进行处理，我们可以使用构造方法（构造器）来完成
public class Person {
String name;
int age;
String sex;
Person() { //构造方法不需要指定返回值，并且方法名称与类名相同
name = "小明"; //构造方法会在对象创建时执行，我们可以将各种需要初始化的操作都在这里进行处理
age = 18;
sex = "男";
}
}
public class Main {
public static void main(String[] args) {
Person p = new Person(); //调用无参构造方法
System.out.println(p.name);
}
}
小明
//在我们自己定义一个构造方法之后，会覆盖掉默认的那一个无参构造方法，除非我们手动重载一个无参构造，否则要创建这个类的对象，必须调用我们自己定义的构造方法
public class Person {
String name;
int age;
String sex;
Person() { //构造方法不需要指定返回值，并且方法名称与类名相同
name = "小明"; //构造方法会在对象创建时执行，我们可以将各种需要初始化的操作都在这里进行处理
age = 18;
sex = "男";
}
Person(String name, int age, String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
}
public class Main {
public static void main(String[] args) {
Person p = new Person("小明", 18, "男"); //调用自己定义的带三个参数的构造方法
System.out.println(p.name);
}
}
静态变量&静态方法
静态内容一定会在第一个对象初始化之前完成加载
//我们通过使用static关键字来声明一个变量或一个方法为静态的，一旦被声明为静态，那么通过这个类创建的所有对象，操作的都是同一个目标，也就是说，对象再多，也只有这一个静态的变量或方法。
public class Person {
String name;
int age;
String sex;
static String info;
//静态代码块可以用于初始静态变量
static {
info = "Apple";
}
static void test(){
//在静态方法中，无法使用this关键字，因为this关键字代表的是当前的对象本身
System.out.println("我是静态方法");
//静态方法可以访问到静态变量，在静态方法中，无法获取成员变量的值
System.out.println("静态变量的值为:" +info);
}
}
public class Main {
public static void main(String[] args) {
Person.info = "Hello World";
System.out.println(Person.info);
Person.test();
}
}