对象的概念
在面向对象里面，万事万物都是对象
对象有两个重要的东西
- 属性：一般是名词，例如：颜色，大小。
- 方法：一般是动词。
类的概念
- 类,其英文是class
- 类是模板，作用就是创建对象，一个类可以创建多个对象。
- 类是抽象的，里面放有属性，方法。
类和对象的关系
- 类是抽象的，对象是具体的。例如：一个类Car，意思就是汽车。对象那么就有很多，比如说宝马，奔驰，凯迪拉克，红旗，比亚迪。
- 对象是类的具体化，类是对象的抽象化。其实这个概念还是上面那个概念。
面向对象和面向过程
先说结论：没有哪个比谁优秀。
面向对象和面向过程是思维。
面向过程，适用于规模比较小的问题，思路就是第一步干什么；第二步干什么；第三步干什么来解决问题。
面向对象，目前在开发界比较流行，因为问题规模比较大，思考的维度比较多，比如说我们要抽象出有哪些对象，对象有哪些属性，有哪些方法。
类的定义
类有几个比较注意的地方
- 类名首字母要大写。
- 类里面就只有两个东西。其一是属性；其二是方法。属性写在一起，方法写在一起，比较好维护，比较符合大宗习惯。
写个汽车类的例子。
public class Car {
//属性写在一起
String brand ; //品牌
String color ; //颜色
int price ; //价格
String type ; //类型
public void start() {
//这个是实例方法，关键就是没有static关键字，这个方法表示启动
System.out.println("启动了，请坐好。") ;
}
public void stop() {
//停止方法
System.out.println("刹车了，请坐好。") ;
}
}
对象的创建
类创建好了，那么就是为对象的创建提供了模板。
以上面的Car类为例，来创建两个汽车对象。
public static void main(String[] args) {
// 创建对象时，如果类中没有构造函数，那么默认的调用系统提供的无参构造函数，这个无参构造函数不用写，系统自动提供。只有构造函数采用new 调用。
Car car1 = new Car() ; //创建对象car1
//给对象的属性赋值，采用 对象.属性赋值
car1.brand = "宝马" ;
car1.color = "white" ;
car1.price = 599999 ;
System.out.println(car1.brand + "是" + car1.color) ;
//调用类中方法。
car1.start();
car1.stop();
Car car2 = new Car() ; //创建对象car2
//给对象的属性赋值，采用 对象.属性赋值
car2.brand = "宝骏" ;
car2.color = "black" ;
car2.price = 199999 ;
System.out.println(car2.brand + "是" + car2.color) ;
car2.start();
car2.stop();
}
局部变量和实例变量
- 对象又可以称为实例。
- 属性可以叫做实例变量。
- 属性有点像数组，在定义时，自动赋初值，整型赋值0；浮点赋值0.0；布尔赋初值false；char赋初值整型0；引用类型赋值null.
方法中定义的临时变量，又称为局部变量，可以与实例变量同名，局部变量优先使用。
//这里举个栗子
public class Car {
//属性写在一起
String brand ; //品牌
String color ; //颜色
int price ; //价格
String type ; //类型
public Car(String brand , String color , int price ,String type ) {
this.brand = brand ;
this.color = color ;
this.price = price ;
this.type = type ;
}
public void start(String brand , String color , int price ,String type ) {
//启动方法
brand = " 奥迪";
color = "white" ;
price = 499999 ;
type = "suv" ;
System.out.println(price + "的" + color + "的" + type + brand + "启动了，请坐好。") ;
}
public void stop() {
//停止方法
System.out.println("刹车了，请坐好。") ;
}
public static void main(String[] args) {
Car car1 = new Car( "红旗" , "red", 894561,"轿车" ) ;
//start()中按照car1对象构造方法传参，没有报错，而且还能运行。
car1.start("红旗" , "red", 894561,"轿车");
}
}//结果如下
实例变量作用域范围在本类中。
实例变量有默认值，与数组类似。局部变量必须要赋值后才能使用。
实例方法
和实例变量差不多的理解方式，就是对象调用类中的方法
**关键点：必须要创建对象后才能使用对象来调用的方法,创建对象就是new一个对象，也是在内存中开辟一个空间 **
实例方法没有static关键字，因为有static 关键字的方法那么自动在内存中开辟空间，就不需要new一个对象然后再去调用，直接采用 类名.方法名 调用。
方法的重载(overload)
重载只用关心一个点，参数列表，至于参数列表在哪 就是方法名后的括号里面的东西，你只用看这里。
重载的定义就是在一个类中定义了相同名称的方法，但是方法的参数列表里面东西有点不同，这个不同只限于参数的类型，个数，以及顺序
有个坑，public void func(int a , int b)和public void func(int m , int n)是方法的重载吗,这个不是，因为参数名不同，其他完全相同其实是同一个方法，因为方法里面的参数是形参，名字可以认为它就是一个形式名，可以自己随便定义，但是都一样
public class Cal {
public int add(int num1 , int num2) {
//两个Int类型
return num1 + num2 ;
}
public double add(double num1 , int num2) {
//一个double, 一个int
return num1 + num2 ;
}
public double add(double num1 , double num2) {
//两个double类型
return num1 + num2 ;
}
public static void main(String[] args) {
Cal cal = new Cal();
cal.add(1, 5);//自动调用两个Int类型
cal.add(1.232, 5.0); //自动调用两个double类型
cal.add(1.5, 5); //自动调用一个double, 一个int
}
}
构造方法
前面注释里面有写创建实例对象时构造方法必须采用new
如果类中不写构造方法，那么，在new构造对象的时候，调用系统自带的无参构造方式。
如果类中写了有参的构造方法，那么就只会调用有参构造方法，在创建对象的时候给参数列表中传参，直接给对象属性赋值
构造方法有两个特点：
- **没有返回值类型，是类型，类型，类型。也就是不写返回值
- 必须和类名同名**
有参数的构造方法的作用：为了在new对象时同时给对象的属性赋值。
下面写个类中不包含构造方法，调用系统自带的构造方法，然后给对象的属性赋值。
public class Car {
//属性写在一起
String brand ; //品牌
String color ; //颜色
int price ; //价格
String type ; //类型
public static void main(String[] args) {
Car car1 = new Car( ) ;//采用系统的无参构造方法
car1.brand = "红旗" ; //就要一一给对象的属性赋值
car1.color = "red" ;
car1.price = 894561 ;
car1.type = "轿车" ;
}
}
再写个有参数的构造方法
public class Car {
//属性写在一起
String brand ; //品牌
String color ; //颜色
int price ; //价格
String type ; //类型
public Car(String brand , String color , int price ,String type ) {
//采用和属性相同类型的参数构造方法，就要采用this.属性 = 变量名
this.brand = brand ;
this.color = color ;
this.price = price ;
this.type = type ;
}
public static void main(String[] args) {
Car car1 = new Car("红旗" , "red", 894561,"轿车" ) ;//调用有参构造方法，直接给car1对象的属性赋值，其中this.属性，就是在new这个对象car1时指代car1的对应属性，this就是指代的对象自己
}
}
this
作用就是：this关键字在类中指代当前实例对象。
一般有两种用法：
1、使用this.属性或this.方法()来调用当前实例的属性或方法。
注意：当前方法中，如果有局部变量的名称与实例变量（属性）名称相同，优先使用局部变量，可以使用this关键字来操作实例变量（属性）。下面给个栗子
2、使用this()来调用当前类中其他的构造方法。
public class Student {
String name;
int age;
String sex;
int score;
// 构造方法
// 当类没有构造方法时，系统会提供一个默认的无参构造方法
public Student() {
System.out.println("构造方法被调用");
}
public Student(String name, int age, String sex) {
// 此处使用this关键字调用属性
this.name = name;
this.age = age;
this.sex = sex;
}
// 全参构造方法
public Student(String name, int age, String sex, int score) {
// 此处使用this关键字调用属性
// this.name = name;
// this.age = age;
// this.sex = sex;
this(name, age, sex); // 调用本类中提供的其他构造方法
this.score = score;
}
public void sayHi() {
this.say(); // 调用当前实例方法，也可以省略掉this
System.out.println("sjdfsldf");
System.out.println("你好，我叫：" + name + "，性别："
+ sex + ", 年龄：" + age + "，这次考试成绩为：" + score);
}
public void say() {
System.out.println("hello, world");
}
}