当前位置:网站首页>static+代码块+多态+异常

static+代码块+多态+异常

2020-11-07 20:55:57 Roy01

1.static的用法

在一个class类中可以存在被static修饰的成员变量和成员方法,被static修饰的成员属性和成员方法可以通过两种方法实现执行。

  1. 第一种是通过类名.静态属性/类名.静态方法执行;
  2. 第二种是通过实例化对象的方式访问,对象名.静态属性和对象名.静态方法。

在静态方法中只能访问静态资源,不能访问非静态资源
在普通方法中可以访问静态方法,也可以访问普通方法

被static修饰的成员变量仅此一份,所有对象所共享。(全局唯一,全局共享)

静态资源随着类的加载而加载,优先于对象加载

只加载一次,就会一直存在,不再开辟新空间

static不能和this或者super共用,因为有static时可能还没有对象

public class Test1_Static {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person.test();//静态方法可以通过类名.方法名直接调用
        System.out.println(Person.age);//静态属性可以通过类名.属性名直接调用
        Person person=new Person();
        System.out.println(person.name);
        person.show();
        System.out.println(person.age);//静态属性可以通过对象名.静态属性调用访问
        person.test();//静态方法也可以通过对象名.静态方法调用
        Person person2=new Person();
        Person person3=new Person();
        person2.age=10;
        System.out.println(person3.age);//被static修饰的成员属性供所有对象使用

    }

}
class Person{
    static int age;
    public static void test() {
        System.out.println("test()....");
//        show();//在jdk8中,静态方法不可以访问普通方法
    }
    String name;
    public void show() {
        System.out.println("show()....");
        test();//在普通方法中可以访问静态方法
    }
}

2.静态代码块,构造代码块,局部代码块

2.1静态代码块

静态代码块的作用是:完成项目的初始化
静态代码块随着类的加载而加载,只会加载一次,贮存在内存中,随着类的消失而消失。
静态代码块存在的位置是类里,成员位置。
触发节点 : 类加载的时候

2.2构造代码块

构造代码块的作用是:提取构造方法中的特性 触发节点:创建对象时

2.3局部代码块

局部代码块存在的位置是,成员方法里
作用是:控制局部变量的作用范围
触发节点:执行目标方法时

2.4执行顺序

静态代码块>构造代码块>构造方法>局部代码块

public class Test2_Block {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BlockDemo().test();
    }

}
class BlockDemo{
    //静态代码块随着类的加载而加载(只会加载一次),加载在内存,所有对象所共享,随着类的消失而消失。触发节点 :加载类的时候
    static {
        System.out.println("我是静态代码块");
    }
    //构造代码块 提取构造方法中的共性,优先于构造方法执行 触发时间点 创建对象时
    {
        System.out.println("我是构造代码块");
    }
    public BlockDemo() {
        
        System.out.println("我是构造方法");
    }
    public void test() {
        //局部代码块 控制变量的作用范围 触发节点 执行方法时
        {
            System.out.println("我是局部代码块");
        }
    }
}

3.final的用法

  1. 被final修饰的类不允许被继承
  2. 被final修饰的方法,子类可以访问但不能重写
  3. 被final修饰的变量称之为常量,子类可以访问
public class Test3_Final {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cat cat=new Cat();
        cat.run();
        System.out.println(cat.age);
    }
    

}
//被final修饰的类不允许被继承
class Animal{
    //被final修饰的方法可以被继承,子类可以访问,但是不能被子类重写,
    final public void run() {
        System.out.println("run().....");
    }
    //被final修饰的变量,,子类可以访问,但是值不能被修改
    final int age=1000;
}
class Cat extends Animal{
    
}

4.多态

多态:同一个对象的多种形态
多态的好处

--1,提高了程序的灵活性和扩展性
--2,多态中,根本不关心具体的子类的类型,可以屏蔽子类间的不 同,把子类都当做父类对待
--3,代码更加通用,做出统一的编程

多态的条件:

--1发生了继承关系,子类重写了父类的方法
--2父类引用指向子类的实例,编译看左边,运行看右边
public class Test4_Multi {
    public static void main(String[] args) {
        Person people=new Chinese();
        people.speak();
    }
}
class Person{
    public void speak() {
        System.out.println("说什么");
    }
}
class Chinese extends Person{
    @Override
    public void speak() {
        System.out.println("说汉语");
    }
}

5.多态的使用

多态的实现条件是

发生了继承关系+子类重写了父类的方法

父类引用指向子类对象,编译看左边运行看右边

父类中的静态方法,子类可以访问,但是不可以重写

多态中使用的成员变量指的是父类的成员变量,

多态指的是父类引用子类对象,子类展现重写父类的方法

public class Test5_UseMulti {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father f=new Son();//父类引用指向子类对象
        f.study();//编译看左边,运行看右边指的是子类重写父类的方法
        f.show();//静态方法不能重写
        Father.show();
        System.out.println(f.sum);//多态中使用的成员变量是父类的成员变量
    }

}
class Father{
    int sum=10;
    public void study() {
        System.out.println("学习养生");
    }
    public static void show() {
        System.out.println("Father...show()");
    }
}
class Son extends Father{
    int sum=20;
    @Override
    public void study() {
        System.out.println("学习Java");
    }
    public static void show() {
        System.out.println("Son...show()");
    }
}

6.异常

异常是指程序中出现的Bug.
try--catch 捕获可能出现的异常,catch对出现的异常进行处理

`   try{
        代码
    }catch(异常类型1 异常名){
        给出解决方案1
    }catch(异常类型2 异常名){
        给出解决方案2
    }
      

`

public class Test6_Exception {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//        method1();
        method2();
    }
    public static void method2() {
        try {
            int a=5;
            int b=0;
            System.out.println(a/b);
        } catch (ArithmeticException e) {
            // TODO Auto-generated catch block
            System.out.println("除数不能为0");
        }
    }
    public static void method1() {
        int a=5;
        int b=0;
        System.out.println(a/b);
    }
}

版权声明
本文为[Roy01]所创,转载请带上原文链接,感谢
https://segmentfault.com/a/1190000037758477