Java基础语法之面向对象

心已赠人 2024-03-31 16:31 116阅读 0赞

## 1. 类和对象 ##

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

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

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

// 对象是将内存地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量
    // 而变量的类型称之为引用数据类型
    User user = new User();
    
    // 特殊的对象：空对象（null），没有引用的对象，也称为关键字对象
    User user = null;

![在这里插入图片描述][a87d4231778b4e689ea8346662d798f2.png]

## 2. 属性 ##

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

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

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

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

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

## 3. 方法 ##

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

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

![在这里插入图片描述][f7b4d85f0369418caa891e7f6bacd9ad.png]

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;
    }

![请添加图片描述][45ad1861a2dc4601a3d253719f2bd4d8.png]

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零基础极速入门][7_Java_Java]

[a87d4231778b4e689ea8346662d798f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a9e6e5caacd34086b64ddf3e08d4f923.png
[f7b4d85f0369418caa891e7f6bacd9ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/dcca73f85f3049af9ad19630b2771224.png
[45ad1861a2dc4601a3d253719f2bd4d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d345f37256714211b59a8d9b6aa0c7ce.png
[7_Java_Java]: https://bilibili.com/video/BV1o841187iP?p=69&vd_source=a1af903e57688df870625021f7f3a7eb