JAVA_Basis -- 4.2 面向对象

1 static

1.1 概念

Java中用于修饰常量，变量，方法的关键字，称为静态常量，静态变量，静态方法，它们都存在与方法区。

1.2 特点

① 这些变量和方法都有独立的生命周期，只需要加载一次，
② 内存中的静态变量可以被其他类类共享，其他类调用时无需实例化。
③ 静态只能调用静态，非静态可以随意调用。
④ static不能和this和super共用，因为有static的时候还没有对象。

1.3 分类

1.3.1 静态常量

在Java语言中使用final static修饰的成员变量就是一个静态常量，静态常量也就是通常意义下的共享常量，一旦赋值完成就不可以进行更改了。

1.3.2 静态变量

在Java语言中使用static修饰的成员变量就是静态变量，可以被不同的类操作，属于类且存储与方法区中，只有一份通过类名进行访问。

1.3.3 静态方法

想要使用类中成员方法，需要先将这个类进行实例化，但是有些时候无法或者不想创建类的对象时，我们还要调 用类中的方法供我们完成业务逻辑代码，此时我们就可以通过静态方法—>调用静态方法，无需创建类的对象

1.3.4 静态代码块

在类中成员方法之外，使用static修饰的代码区域可以称之为静态代码块，定义了一个静态代码块，可以完成类的初始化操作 属于类的，在类被加载期间自动执行。

1.4 案例

package com.mtingcat.javabasis.object.sc;

import java.util.Date;

/**
 * 这个类用来测试静态成员
 * @author MTing
 *
 */
public class student {
	final static int A = 123; //静态常量
	static String Hello = "Hello";  //静态变量
	static {		//静态代码块
		@SuppressWarnings("unused")
		String Today = "Today";
		System.out.println(new Date());
	}
	public static void main(String[] args) {
		@SuppressWarnings("unused")
		String sex = Person.sex1;  //静态变量可以不同创建实例对象就可以调用
		Hello = "Hello===";		//静态变量的值可以更改
		System.out.println(A+","+Hello);
		Person p = new Person("Cat", 22);
		
	}

}
class Person{
	String name;
	int age;
	static String sex1 = "男";
	static String sex2 = "女";
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void study(){
		System.out.println("not static");
	}
	public static void sleep(){
		System.out.println("staic sleep()=====");
	}
}

1.5 静态方法内存图

1.6 拓展

1.6.1 静态代码块，构造代码块，局部代码块概念

① 静态代码块：在类加载的时候就被加载，只能被加载一次，一般用于项目的初始化。
② 构造代码块：在调用构造方法前会自动调用，每次创建对象的时候会被调用。
③ 局部代码块：方法里的代码块，方法被调用的时候才会被执行。

1.6.1.2 案例

package com.mtingcat.javabasis.object.sc;

public class Test {
	public static void main(String[] args) {
		Bird bird = new Bird();
		bird.eat();
	}

}

class Bird{
	int id;
	String name;
	 //静态代码块
    //1，在类第一次加载时就加载到内存中并一直驻存，
    //并全局共享,直到类消失静态资源才消失
    //2，并且静态资源只被加载一次
	static{
		System.out.println("静态代码块");
	}
	
	//构造代码块
	public Bird(){
		System.out.println("无参构造");
	}
	public Bird(int id){
		this.id = id;
		System.out.println("这是有参构造方法");
	}
	public Bird(int id,String name){
		this.id = id;
		this.name = name;
		System.out.println("这是全参构造方法");
	}
	//局部代码块
	public void eat(){
		System.out.println("这是局部代码块");
	}
}

1.6.2 final

final即最终的，可以修饰类，方法和变量，java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。

1.6.2.1 特点

① 被final修饰的类，不能被继承
② 被final修饰的方法，不能被重写
③ 被final修饰的变量是个常量，值不能被更改
④ 常量的定义形式：final 数据类型 常量名 = 值

1.6.2.2 案例

package com.mtingcat.javabasis.object.sc;

public class test02 {
	public static void main(String[] args) {
		Chevrolet c = new Chevrolet();
		c.go();
		System.out.println(c.name);
		c.go00();
	}
	
}
class Car{
	//final class A{}//被final修饰的类不能被继承
	final String name = "大黄蜂";
	public final void go(){
		System.out.println("gogogo");
	}
}

class Chevrolet extends Car{
	//被final修饰的方法不能被重写
	/*public void go(){
		
	}*/
	public void go00(){
	/*	super.name="擎天柱";*///被final的变量，不能重新被赋值
		System.out.println(super.name);
	}
}

1.7 多态

1.7.1 概念

多态指的是同一个对象在不同时刻所有指代的对象不一样，多指同一个对象拥有多种形态，是OOP （Object Oriented Programming） 中一个重要概念。
基于这一特性可以对做出统一的标准，写出通用代码。

class Person{}
class Doctor extends Person{}
Doctor d = new Doctor()
Animal a = new Doctor()//通过创建Doctor对象再赋值给Person对象，即向上造型的形式指的就是多态。

1.7.2 特点

Ⅰ 多态的前提是继承
Ⅱ 要有方法的重写
Ⅲ 父类的引用指向子类的对象
Ⅳ 编译看左边，运行看右边

1.7.3 多态的使用

1.7.3.1 特点

Ⅰ 成员变量：使用的是父类的
Ⅱ 成员方法：由于方法存在重写，所以使用的是子类的。
Ⅲ 静态成员：随着对象而存在，谁调用就使用谁的。

1.7.4 多态的使用

package com.mtingcat.javabasis.object.polymorphic;
/**
 * 多态的入门案例
 * @author MTing
 *
 */
public class Demo {
	
	public static void main(String[] args) {
		
		/**
		 * 向上造型之中只能用父类的属性和方法，并且父类的方法被重写了
		 */
		Plant p = new Flowers();
		p.name = "康乃馨";
		p.statue = "alive";
		System.err.println(p.name + p.statue);
		p.bask();
		
		Flowers f = (Flowers)p;
		f.color = "gree";
		f.looking();
		
		
		Flowers f1 = new Flowers();
		f1.color = "blue";
		f1.looking();
		
	}
	
}

class Plant{
	String name;
	String statue;
	public void bask(){
		System.out.println("沐浴阳光");
	}
}

class Flowers extends Plant{
	String color;
	@Override
	public void bask(){
		System.out.println("沐浴阳光11111");
	}
	public void looking(){
		System.out.println("拥有绚丽的外表");
	}
}

1.7.4.1 特点

Ⅰ 成员变量：使用的是父类的
Ⅱ 成员方法：由于方法存在重写，所以使用的是子类的。
Ⅲ 静态成员：随着对象而存在，谁调用就使用谁的。

1.8 拓展

1.8.1 静态变量和实例变量的区别

Ⅰ 语法：静态变量用static关键字修饰，实例变量则不需要
Ⅱ 类别：静态变量块属于类，实例变量属于对象
Ⅲ 运行：静态变量只要类的字节码文件被加载就存在了，实例变量只有在实例化对象之后才会存在。

1.8.2 向上转型和向下转型

Ⅰ 向上造型：父类的引用指向子类的对象Plant p = new Flowers(); 子类对象被当成父类对象，只能用父类的属性和重写的父类方法
Ⅱ 向下造型：子类的引用的指向子类对象，过程中必须要采取到强制转型。*Flowers f = (Flowers)p;*向下转型既可以使用自己的属性和方法，也可以使用父类的属性和方法。