本文深入探讨了Java编程中的final和static关键字，包括它们的特点、用法和案例。接着介绍了抽象类的概念，强调了抽象类在表示抽象事物和强制子类实现特定方法的作用。此外，还详细讲解了接口的用途，以及类与类、类与接口、接口与接口之间的关系。最后，阐述了包在Java中的作用，以及如何定义和导入包。
抽象类、接口、包
final和static关键字
final关键字
概述及特点
- final关键字是最终的意思，可以修饰类，成员变量，成员方法。
– 修饰类，类不能被继承
– 修饰变量，变量就变成了常量，只能被赋值一次
– 修饰方法，方法不能被重写
案例代码
package com.itheima;
/*
public final class Father {
}
*/
public class Father {
public final void method() {
System.out.println("method father");
}
}
package com.itheima;
public class Son extends Father {
public final int age = 20;
public void show() {
//age = 10;
System.out.println(age);
}
/*
@Override
public void method() {
System.out.println("method son");
}
*/
}
package com.itheima;
/*
* final：是一个关键字，表示最终的意思。可以用来修饰类，修饰变量，修饰方法。
* 修饰类：表明该类是最终类，不能被继承
* 修饰变量：表明该变量是常量，不能再次被赋值
* 修饰方法：表明该方法是最终方法，不能被重写
*/
public class FinalDemo {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
static关键字
概述及特点
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，我们可以通过static关键字来实现不创建对象就调用方法。static它是静态修饰符，一般用来修饰类中的成员。
- 静态的特点
– 被类的所有对象共享 - 这也是我们判断是否使用静态关键字的条件
– 可以通过类名调用
– 优先于对象存在
– 随着类的加载而加载
案例代码
package com.itheima_01;
/*
* static：是一个关键字，静态的意思。可以用来修饰成员变量和成员方法。
* static修饰成员的特点：
* A:被类的所有对象共享。
* 其实也是判断一个成员是否应该用static修饰的条件。
* B:可以通过类名直接访问
* C:优先于对象存在
* D:随着类的加载而加载
*/
public class StaticDemo {
public static void main(String[] args) {
Student.graduateFrom = "传智学院";
Student s1 = new Student();
s1.name = "林青霞";
s1.age = 30;
//s1.graduateFrom = "传智学院";
s1.show();
System.out.println("----------------------");
Student s2 = new Student();
s2.name = "刘德华";
s2.age = 28;
//s2.graduateFrom = "传智学院";
s2.show();
}
}
package com.itheima_01;
public class Student {
public String name;
public int age;
//public String graduateFrom; //毕业院校
public static String graduateFrom; //毕业院校
public void show() {
System.out.println(name+"---"+age+"---"+graduateFrom);
}
}
static方法的访问特点
静态方法只能访问静态的成员变量和静态的成员方法
static方法的注意事项
在静态方法中是没有this,super关键字的
静态的内容是随着类的加载而加载，this和super是随着对象的创建而存在。
案例代码
package com.itheima_02;
/*
* 非静态的成员方法：
* 能访问静态的成员变量
* 能访问非静态的成员变量
* 能访问静态的成员方法
* 能访问非静态的成员方法
*
* 静态的成员方法：
* 能访问静态的成员变量
* 能访问静态的成员方法
*
* 注意事项：
* 静态成员方法中不能出现this,super这样的关键字。
* 原因是：静态是随着类的加载而加载，this,super这样的关键字是随着对象的创建而存在。
* 先进内存的，不能访问后进内存的。
*/
public class Student {
//非静态的成员变量
private String name = "林青霞";
//静态的成员变量
private static int age = 30;
//非静态的成员方法
public void show() {
this.name = "刘德华";
System.out.println(name);
System.out.println(age);
show2();
show4();
}
public void show2() {
}
//静态的成员方法
public static void show3() {
//this.age
//this.name
//System.out.println(name);
System.out.println(age);
//show2();
show4();
}
public static void show4() {
}
}
抽象类
抽象类概述
当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具回想前面我们的猫狗案例，提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal()来创建动物对象的，其实这是不对的。为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
案例代码
package com.itheima_01;
public class AnimalDemo {
public static void main(String[] args) {
/*
Animal a = new Animal();
a.eat();
*/
}
}
package com.itheima_01;
public abstract class Animal {
/*
public void eat() {
System.out.println("吃东西");
}
*/
//抽象方法
public abstract void eat();
}
抽象类的特点
- 抽象类和抽象方法必须用abstract关键字修饰
- 格式:
public abstract class 类名 {}
public abstract void eat(); - 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
- 抽象类不能实例化
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。 - 抽象类的子类要么是抽象类，要么重写抽象类中的所有抽象方法
案例代码
package com.itheima_02;
/*
* 抽象类的特点：
* A:抽象类和抽象方法必须使用abstract关键字修饰
* B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
* C:抽象类不能实例化
* 抽象类如何实例化呢?
* 参照多态的方式，通过子类对象实例化。
* D:抽象类的子类
* 要么重写抽象类中的所有抽象方法
* 要么是抽象类
*/
public class AnimalDemo {
public static void main(String[] args) {
//创建对象
//Animal a = new Animal();
//按照多态的形式实例化抽象类
Animal a = new Cat();
a.eat();
a.sleep();
}
}
package com.itheima_02;
public abstract class Dog extends Animal {
}
package com.itheima_02;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
package com.itheima_02;
//抽象类
public abstract class Animal {
//抽象方法
public abstract void eat();
public void sleep() {
System.out.println("睡觉");
}
}
抽象类的成员的特点
- 成员变量
– 可以是变量
– 也可以是常量 - 构造方法
– 有构造方法，但是不能实例化
– 那么，构造方法的作用是什么呢? - 用于子类访问父类数据的初始化
- 成员方法
– 可以有抽象方法 限定子类必须完成某些动作
– 也可以有非抽象方法 提高代码复用性
案例代码
package com.itheima_03;
/*
* 抽象类的成员特点：
* 成员变量：
* 有成员变量，成员变量可以是变量，也可以是常量。
* 构造方法：
* 有构造方法。
* 抽象类中构造方法的作用?
* 用于子类访问父类数据的初始化。
* 成员方法：
* 有成员方法，成员方法可以是抽象的，也可以是非抽象的。
* 抽象方法：限定子类必须完成某些动作
* 非抽象方法：提高代码的复用性
*/
public class PersonDemo {
public static void main(String[] args) {
Person p = new Student();
p.
最低0.47元/天 解锁文章
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
