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