一、static關鍵字
爲了實現對象之間重複屬性的數據共享，主要用於修飾類的成員
1. 成員變量
1）非靜態成員變量：需要創建對象來訪問
2）靜態成員變量：使用類名直接調用，也可以通過對象訪問
2. 成員方法
可以使用類名直接調用
2.1 靜態函數：
1）靜態函數中不能訪問非靜態成員變量，只能訪問靜態變量
2）靜態方法不可以定義this、super關鍵字
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中的類與類關係
1）is a關係(學生是人)
2）has 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）訪問父類的構造函數
5）this和super類似，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）它指的是“這是不可變的”
2）final關鍵字主要用於成員屬性、類成員、修飾類、方法、以及方法的形參
A．成員屬性是常量，不能被修改：
public static final double PI=3.14;
說明：
public：訪問權限最大
static：內存中只有一份
final：是一個常量
常量名大寫
必須初賦值
B．final修飾類成員：
1）基本數據類型，final使值不變
2）對象引用，final使其引用恆定不變，讓其無法指向一個新的對象，但對象自身可以被修改
3）一般和static關鍵字結合使用：常量可以優先加載，無需等創建對象時再初始化
4）final和static可以互換位置
5）常量一般被修飾爲final
C．final修飾類：
1）該類是最終類，不能被繼承
2）String、Integer類是final：爲了防止代碼功能被重寫，該類沒有必要進行擴展
D．final修飾方法：
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);
}
}