Java基础语法之面向对象

1. 类和对象

Java中的类通常用大写字母开头

Java中的类有三大特性：封装、继承、多态

一般new出来的对象会赋值给变量，方便重复使用

// 对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量
// 而变量的类型称之为引用数据类型
User user = new User();

// 特殊的对象：空对象（null），没有引用的对象，也称为关键字对象
User user = null;

2. 属性

如果在声明属性的同时进行了初始化赋值，那么所有对象的属性就完全相同。

所以如果希望每个对象的属性不一致，那么可以不用在声明属性的时候进行初始化。

那么属性会在构造对象的时候默认初始化，而默认初始化的值取决于属性的类型。

属性不仅仅在当前类中有效，而且可以随着对象在其他地方使用。

变量使用前必须初始化，否则会出现错误，属性可以不用初始化，因为JVM会帮助我们自动完成初始化。

3. 方法

// 当参数的个数不确定，但是类型相同时，可以采用特殊的参数语法声明：可变参数
// 如果参数中还包含其他含义的参数，那么可变参数应该声明在最后。
void test(int age, String... name){
	System.out.println(name);
}

Java中的方法参数的传递为值传递
基本数据类型：数值
引用数据类型：引用地址

public static void main(String[] args){
	String s = "abc";
	test(s);
	System.out.println(s); // abc
}

public static void test(String s){
	s = s + 10;
}

public static void main(String[] args){
	User user = new User();
	user.name = "zhangsan";
	test(user);
	System.out.println(user.name); // lisi
}

public static void test(User user){
	user.name = "lisi";
}

4. 多态

多态：一个对象在不同的场景下表现出来的不同状态和形态。

多态语法其实就是对对象的使用场景进行了约束。

一个对象可以使用的功能取决于引用变量的类型。

public class Java_Object{
	public static void main(String[] args){
		Person p = new Person();
		p.testPerson();
		Person p1 = new Boy();
		p1.testPerson();
		// p1.testBoy(); // 会报错
		Person p2 = new Girl();
		p2.testPerson();
		// p2.testGirl(); // 会报错

		Boy boy = new Boy();
		boy.testBoy();

		Girl girl = new Girl();
		girl.testGirl();
	}
}
class Person{
	void testPerson(){
		System.out.println("test person...");
	}
	void testBoy(){
		System.out.println("test boy...");
	}
	void testGirl(){
		System.out.println("test girl...");
	}
}

5. 重写

public static void main(String[] args){
		CCC ddd = new DDD();
		// 一个对象能使用什么方法，取决于引用变量的类型
		// 一个对象能使用什么属性，取决于引用变量的类型
		// 一个对象的方法具体的使用是需要看具体的对象的
		// 一个对象的属性具体的使用是不需要看具体的对象的，属性在哪里声明在哪里使用
		System.out.println(ddd.sum());
	}
}

class CCC{
	int i = 10;
	int sum(){
		return i + 10;
	}
}

class DDD extends CCC{
	int i = 20;
	int sum(){
		return i + 20;
	}
}

6. 访问权限

public: 公共的，访问权限修饰符
Java的源码中，公共类只能有一个，而且必须和源码文件名相同。
main方法：main方法是由JVM调用的，JVM调用时应该可以任意调用，而不用考虑权限问题。

Java中的访问权限主要分为4种：

1. private：私有的，同一个类中可以使用。
2. （default）：默认权限，当不设定任何权限时,JVM会默认提供权限，包（路径）权限。
3. protected：受保护的权限，子类可以访问。
4. public：公共的，任意使用。

7. 内部类和外部类

public class Object{
	public static void main(String[] args){
		// Java不允许外部类使用private，protected修饰
		// 所谓的外部类，就是在源码中直接声明的类
		// 所谓的内部类，就是类中声明的类
	
		// 内部类就当成外部类的属性使用即可
	
		// 因为内部类可以看作外部类的属性，所以需要构建外部类对象才可以使用
		OuterClass outer = new OuterClass();
		OuterClass.InnerClass innerClass = outer.new InnerClass();
	}
}

class OuterClass{
	public class InnerClass{
	
	}
}

8. 单例模式

public class Java_Object{
	// TODO 面向对象 - 单例模式
	// 1. 类的创建过程复杂
	// 2. 类的对象消耗资源
	User instance1 = User.getInstance();
	User instance2 = User.getInstacne();
	System.out.println(instance1.equals(instance2));
}

class User{
	private static User user = null;
	private User(){
	
	}
	public static User getInstance(){
		if(user = null){
			user = new User();
		}
		return user;
	}
}

9. Final

final可以修饰变量：变量的值一旦初始化后无法修改。
final可以修饰属性：那么JVM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化。
一般将final修饰的变量称之为常量，或者叫不可变变量。
final可以修饰方法，这个方法不能被子类重写。
final可以修饰类，这样类就没有子类了。
final不可以修饰构造方法。
final可以修改方法的参数，一旦修饰，参数就无法修改。

10. 抽象类和抽象方法

抽象类：不完整的类，就是抽象类
abstract class 类名
因为类不完整，所以无法直接构造对象

抽象方法：只有声明，没有实现的方法
abstract 返回值类型 方法名（参数）

如果一个类中含有抽象方法，那么这个类是抽象类。
如果一个类是抽象类，它的方法不一定是抽象方法。
抽象类无法直接构建对象，但是可以通过子类间接构建对象。
如果抽象类中含有抽象方法，那么子类继承抽象类，需要重写抽象方法，将方法补充完整。

11. Bean类的设计规范：Bean规范

1. 类要求必须含有无参，公共的构造方法。
2. 属性必须私有化，然后提供公共的set，get方法。

参考资料：7天搞定Java基础，Java零基础极速入门