java-类与对象

对象的概念

在面向对象里面，万事万物都是对象

对象有两个重要的东西

• 属性：一般是名词，例如：颜色，大小。
• 方法：一般是动词。

类的概念

• 类,其英文是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");
	}
}