007面线对象oop-Static三种代码块final多态

1.Static
1.1概念
static是java中的一个关键字,用于修饰城南公园变量和成员方法.
1.2特点

1. 可以用于修饰成员变量与成员方法
2. 随着类的加载而加载,优先于类加载
3. 只加载一次,就会一直存在,不在开辟新矿建,直到类小孩才一起消失
4. 静态资源也叫作类资源,全局唯一,被全局所有对象共享
5. 可以直接被类名调用
6. 静态只能静态调用,非静态可以被随意调用
7. static不能和this关键字中和super共用,因为有static时可能还没有对象

练习案例:static入门案例

package day08;

public class oopStatic {
	public static void main(String[] args) {
		System.out.println(Student.name);// null
		Student.study();// 正在学习java
		final Student s = new Student();
		s.name = "黄桃罐头";
		System.out.println(s.name);// 黄桃罐头
		s.study();// 正在学习java
		s.play();// 正在玩手机
		final Student s2 = new Student();
		System.out.println(s2.name);// 黄桃罐头
		System.out.println(Student.name);// 黄桃罐头
	}
}

class Student {
	int sno;
	static String name;

	public static void study() {
		System.out.println("正在学习java");
	}

	public void play() {
		System.out.println("正在玩手机");
	}
}

练习2:Static静态调用关系
测试静态资源的调用关系

package day08;

public class oopstatic2 {

}

class Teacher {
	String name;

	public void teach() {
		System.out.println(age);
		System.out.println("老师正在上课~");
		sleep();
	}

	static int age;

	public void sleep() {
		System.out.println(name);
		teach();
		System.out.println(age);
		eat();
		System.out.println("周末好好休息");
	}

	private void eat() {
		System.out.println("在忙也要好好吃饭哦");
	}
}

总结:

1. 静态资源只能调用静态资源,不能调用非静态资源以外的资源
2. 非静态资源即可以调用静态资源,也可以调用非静态资源

2.静态代码块\构造代码块\局部代码块
2.1静态代码块格式
static{}
静态资源随着类的加载而加载,并且纸杯加载一次,一般用于项目的初始化
特点:被static修饰,位置在类里面方法外面
2.2三种代码块的比较

1. 静态代码块:在类加载时加载,并且只被加载一次,一般用于项目的初始化
2. 构造代码块:在创建对象时就会自动调用,每次创建对象都会被调用,提取构造共性
3. 局部代码块:方法里的代码块,限制局部变量的范围

练习3:几种代码块的关系

package day08;

public class BlockTest {
	static {
		System.out.println("我是公共类的静态代码块");
	}

	public static void main(String[] args) {
		System.out.println("1");
		final Person p = new Person();
		System.out.println("------------");
		p.study();
		System.out.println("----------");
		final Person p2 = new Person();
	}
}

class Person {
	static {
		System.out.println("我是Person类的静态代码块");
	}
	{
		System.out.println("我是构造代码块");
	}

	public Person() {
		System.out.println("我是构造方法");
	}

	public void study() {
		System.out.println("我是普通方法");
		{
			System.out.println("我是局部代码块");
		}
	}
}

几种代码块之间的执行顺序如下:静态代码块–>构造代码块—>构造方法—>局部代码块
这种顺序的原因是:

1. 静态代码块优先于对象加载,是随着类的加载就会第一时间加载进入内存,并且一直存在,直到类消失才会消失
2. 静态代码块的作用:专门用来完成一些需要第一时间加载并且只需要加载一次的资源
3. 构造代码块:是在创建对象时候才会触发,专门用来提取构造方法的共性
4. 局部代码块:是在方法调用时候才会触发,专门从来控制变量的作用范围

3.final

3.1概念

• final是java提供的关键字
• final是最终的意思
• final可以修饰类\方法\变量
• java出现继承以后,子类可以更改父类的功能,当父类功能不允许子类改变时,可用final关机簪子修饰父类

3.2特点

• 被final修饰的类,不能被继承
• 被final修饰发的方法,不能被重写
• 被final修饰的 变量是个常量,值不能被改变
• 常量的定义形式: final 数据类型 常量名 =值

3.3练习final的案例

package day08;

public class FinalTest {
	public static void main(String[] args) {
		final Son s = new Son();
		s.work();
		//s.name="打工人";//The final field Father.name cannot be assigned
	}
}
class  Father {
	final  String name = "打工人";
	final public void work() {
		System.out.println("走!进厂打工去~");
	}
}
class Son extends Father{
//	public void work() {
//		System.out.println("走!到大厂去打工~");//Cannot override the final method from 
//	}
}

4多态
多态指的是一个实体同时具有多种形式
它是面向对象程序设计(oop)的一个重要特征
主要是值得失同一个对象,代表的对象不一样,指的是对象的多种形态
多态的好处是:可以把不同的子类对象都当做父类来看待,可以屏蔽不同子类对象之间的差异,写出通用性较高的编程,统一调用标准.
例如:水果有两种形态:水果和苹果,不关心买回来的是苹果还是西瓜,只要是水果就行

package day08;

public class Test5 {
	public static void main(String[] args) {
		final Animal a = new Animal();
		a.eat();
		Cat c = new Cat();
		c.eat();
		c.jump();
		Animal a2 = new Cat();
		Animal a3 = new Dog();
		a2.eat();
		a3.eat();
	}

}

class Animal {
	public void eat() {
		System.out.println("小动物爱吃各种食物");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("小猫爱吃鱼");
	}

	public void jump() {
		System.out.println("小猫喜欢玩老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("小狗爱吃骨头");
	}
}

4.2特点

1. 多态的前提是继承\与方法的重写
2. 父类引用子类对象,如:Animal a = new Cat();
3. 多态中:编译看左边,运行看右边
   
   4.3多态案例

package day08;

public class Polymorphism {
	public static void main(String[] args) {
		final Dog2 d = new Dog2();
		System.out.println(d.sum);// 20
		d.eat(); // 小狗爱吃肉骨头
		d.play();// 小狗爱打滚
		Animal2 dog2 = new Dog2();
		System.out.println(dog2.sum);// 10
		dog2.eat();// 小狗爱吃肉骨头
		dog2.play();// 玩好玩的就行
	}
}

class Animal2 {
	int sum = 10;

	public void eat() {
		System.out.println("吃好吃的就行");
	}

	public static void play() {
		System.out.println("玩好玩的就行");
	}
}

class Dog2 extends Animal2 {
	int sum = 20;

	@Override
	public void eat() {
		System.out.println("小狗爱吃肉骨头");
	}

	public static void play() {
		System.out.println("小狗爱打滚");
	}

}

多态案例的拓展

package day08;

public class TestDesignCar {
	public static void main(String[] args) {
		final Car car = new Car();
		car.run();// 汽车出发啦
		car.stop();// 汽车停下来了

		Car carA = new CarA();
		carA.run();// 汽车出发啦,汽车加速出发啦
		carA.stop();// 汽车停下来了
		Car carB = new CarB();
		carB.run();// 汽车出发啦
		carB.stop();// 汽车慢慢停下了
	}
}

class Car {
	String brand;
	String color;

	public void run() {
		System.out.println("汽车出发啦");
	}

	public void stop() {
		System.out.println("汽车停下来了");
	}
}

class CarA extends Car {
	public void run() {
		super.run();
		System.out.println("汽车加速出发啦");
	}
}

class CarB extends Car {
	public void stop() {
		System.out.println("汽车慢慢停下了");
	}
}

静态变量和实例变量之间的区别:
在语法定义上的区别:静态变量前面要加上static关键字,而实例变量前则不加
在程序运行时候:实例变量属于某个对象的属性,必须闯进了实例对象,其中的实例变量才会被分配空间,才能够使用这个实例变量.静态变量不属于某个实例对象,而是属于类,所以也被称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就额可以被使用了.总之,事例变量必须创建对象之后才可以通过这个对象来使用,讲台变量则可以直接使用类名来引用.

向上转型和向下转型

在java中,继承是一个重要的特征,通过extends关机簪子,子类可以服用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展.
在应用中存在着两种转型方式,分别是:向上转型和向下转型.
例如:父类Parent,子类Child
向上转型:父类的引用纸箱子类对象Parent p = new Child();
说明:向上转型时,子类对象当成是父类对象,只能调用父类的功能,如果子类重写了父类的方法就根据这个引用指向子类重写方法.
向下转型(较少):子类的引用对象指向子类对象,过程中必须要采取到强制转型
Parent p = new Child();//向上转型,此时,p是Parent类型
Child c = (Child)p;//此时,把Parent类型的p转型成为小类型Child
其实,相当于创建了一个子类对象,可以用父类的,也可以用自己的
说明:向下转型时,是为了方便子类的特殊用法,也就是说子类方法做了功能拓展,就可以直接使用子类功能