1.Static
1.1概念
static是java中的一个关键字,用于修饰城南公园变量和成员方法.
1.2特点
- 可以用于修饰成员变量与成员方法
- 随着类的加载而加载,优先于类加载
- 只加载一次,就会一直存在,不在开辟新矿建,直到类小孩才一起消失
- 静态资源也叫作类资源,全局唯一,被全局所有对象共享
- 可以直接被类名调用
- 静态只能静态调用,非静态可以被随意调用
- 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("在忙也要好好吃饭哦");
}
}
总结:
- 静态资源只能调用静态资源,不能调用非静态资源以外的资源
- 非静态资源即可以调用静态资源,也可以调用非静态资源
2.静态代码块\构造代码块\局部代码块
2.1静态代码块格式
static{}
静态资源随着类的加载而加载,并且纸杯加载一次,一般用于项目的初始化
特点:被static修饰,位置在类里面方法外面
2.2三种代码块的比较
- 静态代码块:在类加载时加载,并且只被加载一次,一般用于项目的初始化
- 构造代码块:在创建对象时就会自动调用,每次创建对象都会被调用,提取构造共性
- 局部代码块:方法里的代码块,限制局部变量的范围
练习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("我是局部代码块");
}
}
}
几种代码块之间的执行顺序如下:静态代码块–>构造代码块—>构造方法—>局部代码块
这种顺序的原因是:
- 静态代码块优先于对象加载,是随着类的加载就会第一时间加载进入内存,并且一直存在,直到类消失才会消失
- 静态代码块的作用:专门用来完成一些需要第一时间加载并且只需要加载一次的资源
- 构造代码块:是在创建对象时候才会触发,专门用来提取构造方法的共性
- 局部代码块:是在方法调用时候才会触发,专门从来控制变量的作用范围
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特点
- 多态的前提是继承\与方法的重写
- 父类引用子类对象,如:Animal a = new Cat();
- 多态中:编译看左边,运行看右边
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
其实,相当于创建了一个子类对象,可以用父类的,也可以用自己的
说明:向下转型时,是为了方便子类的特殊用法,也就是说子类方法做了功能拓展,就可以直接使用子类功能