一、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);
    }
}