码迷,mamicode.com
首页 > 其他好文 > 详细

static关键字和继承

时间:2018-04-26 19:05:31      阅读:195      评论:0      收藏:0      [点我收藏+]

标签:java

一、static关键字

为了实现对象之间重复属性的数据共享,主要用于修饰类的成员

1. 成员变量

1)非静态成员变量:需要创建对象来访问

2)静态成员变量:使用类名直接调用,也可以通过对象访问

 

2. 成员方法

可以使用类名直接调用

2.1 静态函数:

1)静态函数中不能访问非静态成员变量,只能访问静态变量

2)静态方法不可以定义thissuper关键字

3)静态优先于对象存在,静态方法中不可有this

 

2.2 非静态函数:非静态函数中可以访问静态成员变量

 

3.特点

1)静态会随着类的加载而加载,随着类的消失而消失

2)优先于对象存在,即静态先存在,对象后存在

3)被所有实例(对象)所共享

4)可以直接被类名调用    

 

 

例子

[root@bch04 java]# cat Demo.java

class Person {

    String name;

    int age;

    String gender;

 

    //静态成员变量

    static String country = "CN";

   

    static {

        System.out.println("这是静态代码块");

    }

 

    {

        System.out.println("这是构造代码块");

    }

 

    Person() {

        System.out.println("这是无参数构造");

    }

 

    Person(String name, int age, String gender) {

        this.name = name;

        this.age = age;

        this.gender = gender;

        System.out.println("有参构造");

    }

    //静态方法

    static void run() {

        //静态方法只能访问静态成员变量

        System.out.println("country:" +country);

    }

 

}

 

    //非静态方法

void speak() {

 

        //非静态方法可以访问静态成员

        System.out.println("name:" +name +"age:" +age +"gender:" +gender +"country:" +country +":heihei!");

 

        //非静态方法可以调用静态方法

        run();

    }

 

 

public class Demo {

public static void main(String[] args) {

 

        //直接通过类名来调用访问静态成员

        String country = Person.country;

        System.out.println(country);

  

        //通过对象.成员的形式来访问

        Person p1 = new Person("tom", 28 ,"");

        p1.country = "US";

        p1.speak();

   }

 

}

 

//运行结果

[root@bch04 java]# java Demo

这是静态代码块

CN

这是构造代码块

有参构造

name:tomage:28gender:country:US:heihei!

country:US

 

 

[root@bch04 java]# cat Demo6.java

class Arrays {

 

       private Arrays() {

 

       }

 

       //定义一个遍历数组的函数

       public static void print(int[] arr) {

              for (int x = 0; x < arr.length; x++) {

                     if (x != (arr.length - 1)) {

                            System.out.print(arr[x] + ",");

                     } else {

                            System.out.print(arr[x]);

                     }

 

              }

       }

 

       //定义一个求数组和的功能函数

       public static int getSum(int[] arr) {

              int sum = 0;

              for (int x = 0; x < arr.length; x++) {

                     sum += arr[x];

              }

              return sum;

       }

 

       //定义一个获取数组最大值的功能函数

       public static int getMax(int[] arr) {

              int max = 0;

              for (int x = 0; x < arr.length; x++) {

                     if (arr[max] < arr[x]) {

                            max = x;

                     }

              }

              return arr[max];

       }

 

       //定义一个获取数组最大值角标的功能函数

       public static int getIndexMax(int[] arr) {

              int max = 0;

              for (int x = 0; x < arr.length; x++) {

                     if (arr[max] < arr[x]) {

                            max = x;

                     }

              }

              return max;

       }

 

       //定义一个返回 指定数在指定数组中包含的角标的功能函数

       public static int getIndex(int[] arr, int src) {

              int index = -1;

              for (int x = 0; x < arr.length; x++) {

                     if (arr[x] == src) {

                            index = x;

                     }

              }

              return index;

       }

 

       //冒泡法排序

       public static void test(int[] arr) {

              for (int x = 0; x < arr.length - 1; x++) {

                     if (arr[x] > arr[x + 1]) {

                            int temp = arr[x + 1];

                            arr[x + 1] = arr[x];

                            arr[x] = temp;

 

                     }

              }

       }

 

       //选择法排序

       public static void selectSort(int[] arr) {

              for (int x = 0; x < arr.length - 1; x++) {

                     for (int y = 1 + x; y < arr.length; y++) {

                            if (arr[x] > arr[y]) {

                                   int temp = arr[y];

                                   arr[y] = arr[x];

                                   arr[x] = temp;

                            }

                     }

              }

       }

 

       //反序排序

       public static void reverseSort(int[] arr) {

              int start = 0;

              int end = arr.length - 1;

              for (int x = 0; x < arr.length; x++) {

                     if (start < end) {

                            int tem = arr[start];

                            arr[start] = arr[end];

                            arr[end] = tem;

                     }

                     start++;

                     end--;

              }

 

       }

 

       //折半法查找

       public static int halfSearch(int key, int[] arr) {

              int min = 0;

              int max = arr.length - 1;

              int mid = 0;

 

              while (min < max) {

                     mid = (min + max) / 2;

                     if (key > arr[mid]) {

                            min = mid + 1;

                     } else if (key < arr[mid]) {

                            max = mid - 1;

                     } else {

                            return mid;

                     }

              }

              return -1;

       }

 

}

 

class Demo6 {

    public static void main(String[] args) {

       int[] arr = { 3, 4, 5, 2, 1, 7, 6 };

 

       System.out.print("遍历数组排序:");

       Arrays.print(arr);

       System.out.println();

 

       System.out.print("选择法后排序:");

       Arrays.selectSort(arr);

       Arrays.print(arr);

       System.out.println();

 

       System.out.print("反序后的排序:");

       Arrays.reverseSort(arr);

       Arrays.print(arr);

       System.out.println();

 

       System.out.print("冒泡法后排序:");

       Arrays.selectSort(arr);

       Arrays.print(arr);

       System.out.println();

      

    System.out.print("数组元素之和:");

    System.out.println(Arrays.getSum(arr));

      

    System.out.print("数组最大元素:");

    System.out.println(Arrays.getMax(arr));

      

    System.out.print("最大元素角标:");

    System.out.println(Arrays.getIndexMax(arr));

 

       System.out.print("遍历查找指定元素6的角标:");

    System.out.println(Arrays.getIndex(arr,6));

 

       System.out.print("折半查找指定元素6的角标:");

    System.out.println(Arrays.halfSearch(6,arr));            

    }

}

 

//运行结果

[root@bch04 java]# java Demo6

遍历数组排序:3,4,5,2,1,7,6

选择法后排序:1,2,3,4,5,6,7

反序后的排序:7,6,5,4,3,2,1

冒泡法后排序:1,2,3,4,5,6,7

数组元素之和:28

数组最大元素:7

最大元素角标:6

遍历查找指定元素6的角标:5

折半查找指定元素6的角标:5

 

 

二、main方法

主函数是一个特殊的函数,作为程序的入口,可以被jvm识别,是静态的,格式:

public static void main(String[] args){

}

 

定义:

public:表示该函数的访问权限最大

static:表示主函数随着类的加载,就已存在

void:主函数没有具体返回值

main:不是关键字,是一个特殊的单词可以被jvm识别

(String[] args):函数的参数,类型为数组,元素为字符串,即字符串类型的数组,jvm在调用函数时,传入的是new String[0]

 

例子:

[root@bch04 java]# cat Maintest.java

class Demo {

    public static void main(String[] args) {

        System.out.println(args.length);

        for (int x = 0; x<args.length ;x++) {

            System.out.println(args[x]);

        }

 

    }

 

}

 

public class Maintest {

    public static void main(String[] args) {

        String [] arr = {"ni","hao","world"};

        Demo.main(arr);

 

    }

 

}

 

//运行结果

[root@bch04 java]# java Maintest

3

ni

hao

world

 

 

三、java中的类与类关系

1is a关系(学生是人)

2has a 整体与部分

 

例子

[root@bch04 java]# cat Demo3.java

class Person{

    String name;

    int age;

    Address add;

   

    Person(){ 

    }

   

    Person(String name,int age,Address add){     

       this.name=name;

       this.age=age;

       this.add=add;

    }

   

    void speak(){

       System.out.println("姓名:"+name+" 年龄:"+age+" "+add.print());

    }

}

 

 

class Address{

    String country;

    String city;

    String street;

   

    Address(){

    }

   

    Address(String country,String city,String street){

       this.country = country;

       this.city = city;

       this.street = street;

    }

   

    String print(){

       return "地址:"+country+" "+"城市:"+city+"  街道;"+street;

    }

}

 

 

class Demo3{

    public static void main(String[] args){      

       Address addr = new Address("中国","深圳","南山大道");

       Person p = new Person("jack",27,addr);

       p.speak();

        }

}

 

//运行结果

[root@bch04 java]# java Demo3

姓名:jack 年龄:27 地址:中国 城市:深圳  街道;南山大道

 

 

四、继承

降低对象和对象之间的代码重复性,使用静态变量;而降低类和类之间的代码重复性,就使用就继承

 

1.特点:

1)类名的设定,被继承的类称之为父类(基类),继承的类称之为子类

2)子类并不能继承父类中所有的成员:

A.父类定义完整的成员,包括静态成员、非静态、构造方法。静态变量和静态方法都可以通过子类名.父类静态成员的形式调用成功

B. 所有的私有成员不能继承,即private修饰的成员

C. 构造函数不能被继承

 

2.extends关键字

继承使用extends关键字实现

 

 

例子

[root@bch04 java]# cat Demo1.java

class Person {

    String name;

    int age;

 

    //静态变量(类变量)对象和对象之间的代码重复使用静态变量

    static String country = "CN";

 

    Person() {

    }

 

    void speak() {

       System.out.println(name + ":哈哈,我是人!!!");

    }

}

 

//学生类和人类产生关系,使用继承

class Student extends Person {

    Student() {

    }

 

    void study() {

       System.out.println("姓名:" + name + "年纪:" + age + ":好好学习");

    }

}

 

class Worker extends Person {

    void work() {

       System.out.println(name + ":好好工作,好好挣钱。");

    }

}

 

class Demo1 {

    public static void main(String[] args) {

       Student stu = new Student();

       stu.name = "tom";

       stu.age = 28;

       stu.study();

       stu.speak();

       System.out.println(stu.country);

       System.out.println(Student.country);

 

       Worker worker = new Worker();

       worker.name = "joy";

       System.out.println(worker.country);

       worker.work();

       worker.speak();

    }

}

 

//运行结果

[root@bch04 java]# java Demo1

姓名:tom年纪:28:好好学习

tom:哈哈,我是人!!!

CN

CN

CN

joy:好好工作,好好挣钱。

joy:哈哈,我是人!!!

 

 

3.super关键字

特点:

1)主要存在于子类方法中,用于指向子类对象中父类对象

2)访问父类的属性

3)访问父类的函数

4)访问父类的构造函数

5thissuper类似,this指向的是当前对象的调用,super指向的是当前调用对象的父类

6子类的构造函数第一行会默认调用父类无参的构造函数,隐式语句;如父类无参构造函数不存在,编译报错

 

例子

[root@bch04 java]# cat Demo6.java

class Father {

    int x = 1;

 

    Father() {

       System.out.println("这是父类无参构造");

    }

 

    Father(int x) {

       this.x = x;

       System.out.println("这是父类有参构造");

    }

 

    void speak() {

       System.out.println("我是父亲");

    }                 

}

 

 

class Son extends Father {

    int y = 1;

    Son() {

       System.out.println("这是子类的无参构造");

    }

 

    Son(int y) {

       this.y = y + x;

       System.out.println("这是子类的有参构造");

    }

 

    void run() {

       super.speak();

    }

}

 

 

class Demo6 {

    public static void main(String[] args) {

       Son s = new Son(3);

       System.out.println(s.y);

                s.run();

                System.out.println("**************");

                s.speak();

    }

}

 

//运行结果

[root@bch04 java]# java Demo6

这是父类无参构造

这是子类的有参构造

4

我是父亲

**************

我是父亲

 

 

 

4.重载和重写

重载(overload) 

1)所有的重载函数必须在同一个类中

2)函数名相同,参数列表不同,与其他的无关(访问控制符、返回值类型)

3)个数不同 顺序不同、 类型不同

 

重写(override)

1)继承

2)函数名必须相同、参数列表必须相同

3)子类的返回值类型要等于或者小于父类的返回值

 

 

例子

class Father {

    String name;

    void eat() {

       System.out.println("吃窝窝");

    }

}

 

class Son extends Father {

    public void eat() {

       System.out.println("来俩小菜");

       System.out.println("来两杯");

    }

}

 

class Demo8 {

    public static void main(String[] args) {

       Son s = new Son();

       s.eat();

    }

}

 

 

[root@bch04 java]# java Demo8

来俩小菜

来两杯

 

 

5.instanceof 关键字

1)属于比较运算符

2)用来判断一个对象是否是指定类的对象

3)返回的结果是boolea类型true|false

4)做判断时,两个类之间必须有关系

5)用法:

Person p=new Person();

System.out.println( p instanceof Person);  //对象  instanceof ;

 

 

 

例子

class Animal {

    String name;

    void eat() {

       System.out.println("吃东西");

    }

 

    void shout() {

       System.out.println("我是动物");

    }

}

 

class Dog extends Animal {

    void eat() {

       System.out.println("啃骨头");

    }

 

    void shout() {

       System.out.println("旺旺");

    }

}

 

class Cat extends Animal {

    void eat() {

       System.out.println("吃老鼠");

    }

    void shout() {

       System.out.println("喵喵");

    }

}

 

class Demo1 {

    public static void main(String[] args) {

       Demo11 d = new Demo1();

 

        //对象 instanceof ;

       System.out.println(d instanceof Demo1);

       d.doSomething(new Dog());

       d.doSomething(new Cat());

    }

 

    void doSomething(Animal a) {

       if (a instanceof Dog) {

           a.eat();

           a.shout();

           System.out.println("小狗看家");

       } else if (a instanceof Cat) {

           a.eat();

           a.shout();

           System.out.println("抓老鼠");

       }

    }

}

 

//运行结果

[root@bch04 java]# java Demo1

true

啃骨头

旺旺

小狗看家

吃老鼠

喵喵

抓老鼠

 

 

6. final关键字

1)它指的是这是不可变的

2final关键字主要用于成员属性、类成员、修饰类、方法、以及方法的形参

 

A.成员属性是常量,不能被修改:

public static final double PI=3.14;

 

public:访问权限最大

static:内存中只有一份

final:是一个常量

常量名大写

必须初赋值

 

Bfinal修饰类成员:

1)基本数据类型,final使值不变

2)对象引用,final使其引用恒定不变,让其无法指向一个新的对象,但对象自身可以被修改

3)一般和static关键字结合使用:常量可以优先加载,无需等创建对象时再初始化

4finalstatic可以互换位置

5)常量一般被修饰为final

 

Cfinal修饰类:

1)该类是最终类,不能被继承

2StringInteger类是final:为了防止代码功能被重写,该类没有必要进行扩展

 

Dfinal修饰方法:

1)该方法是最终方法,不能被重写

2)当一个类被继承,那么所有的非私有函数都将被继承,如果函数不想被子类继承并重写可以将该函数final修饰

3)当一个类中的函数都被修饰为final时,可以将类定义为final

 

例子

class Demo12 {

    public static final double PI = 3.14; // 静态常量

 

    public static double getArea(double r) {

       return PI * r * r;

    }

 

    public static double getLength(double r) {

       return PI * r * 2;

    }

 

    public static void main(String[] args) {

 

       // Demo12.PI=300; 无法为最终变量 PI 指定值

       System.out.println(Demo12.PI);

    }

}


static关键字和继承

标签:java

原文地址:http://blog.51cto.com/huangzp/2108268

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!