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 案例

JAVA_Basis -- 4.2 面向对象_第1张图片

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 静态方法内存图

JAVA_Basis -- 4.2 面向对象_第2张图片

1.6 拓展

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

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

1.6.1.2 案例

JAVA_Basis -- 4.2 面向对象_第3张图片

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 案例

JAVA_Basis -- 4.2 面向对象_第4张图片

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 多态的使用

JAVA_Basis -- 4.2 面向对象_第5张图片

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;*向下转型既可以使用自己的属性和方法,也可以使用父类的属性和方法。

你可能感兴趣的:(JAVA_Basis,java)