目录
final关键字：
final是一个关键字，表示最终的意思。可以修饰类，修饰变量，修饰方法
修饰类：表明该类是最终类，不能被继承
修饰变量：表明该变量是常量，不能再被赋值
修饰方法：表明该方法为最终方法，不能被重写
static关键字：
static是一个关键字，静态的意思，可以用来修饰成员变量和成员方法。
static修饰成员的特点：
A：被类的所有对象共享
B：可以通过类名直接访问
C：优先于对象存在
D：随着类的加载而加载
public class Student {
public String name;
public int age;
public static String graduateSchool;
public void show(){
System.out.println(name+"---"+age+"---"+graduateSchool);
}
}public class StaticDemo {
public static void main(String[] args) {
Student s1 = new Student();
Student.graduateSchool = "清华大学";
//s1.graduateSchool = "清华大学";
s1.age = 30;
s1.name = "张三";
s1.show();
Student s2 = new Student();
//s2.graduateSchool = "清华大学";
s2.age = 30;
s2.name = "张三";
s2.show();
}
}输出结果：
张三---30---清华大学
张三---30---清华大学
static方法访问的特点及注意事项：
非静态的成员方法：
能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法
静态的成员方法：
能访问静态的成员变量
能访问静态的成员方法
注意事项：
静态成员方法中不能出现this，super这样的关键字
原因：静态是随着类的加载而加载，this，super这样的关键字是随着对象的创建而存在。
先进内存的，不能访问后进内存的。
public class Student {
//非静态的成员变量
private String name;
//静态的成员变量
private static int age;
//非静态成员方法
public void show() {
System.out.println(name);
System.out.println(age);
show2();
show4();
}
public void show2() {
}
//静态成员方法
public static void show3() {
//this.age
//System.out.println(name);
System.out.println(age);
//show();
show4();
}
public static void show4() {
}
}抽象类：
关键字：abstract
public abstract class Animal {
public abstract void eat();//抽象方法
}public class AnimalDemo {
public static void main(String[] args) {
//Animal a = new Animal();
//a.eat();
}
}抽象类的特点：
A：抽象类和抽象方法必须使用abstract关键字修饰
B：抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
C：抽象类不能实例化
抽象类如何实例化？：参照多态方式，通过子类对象实例化
D：抽象类子类
要么重写抽象类中所有的抽象方法，要么是抽象类
public abstract class Animal {
//抽象方法
public abstract void eat();
public void sleep(){
System.out.println("睡觉");
}
}public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}public class AnimalDemo {
public static void main(String[] args) {
//Animal a = new Animal();
//a.eat();
Animal a = new Cat();
a.eat();
a.sleep();
}
}输出结果：
猫吃鱼
睡觉
抽象类的成员特点：
成员变量：有成员变量，成员变量可以是变量，可以是常量。
构造方法：有构造方法
构造方法的作用：用于子类访问父类数据的初始化
成员方法：
有成员方法，成员方法可以是抽象的，也可以是非抽象的。
抽象方法：限定子类必须完成某些动作
非抽象方法：提高代码的复用性
抽象类的练习：
老师案例
分析：
基础班老师：
成员变量：name，age
构造方法：无参，带参
成员方法：getXxx（），setXxx（），teach（）{}
就业班老师：
成员变量：name，age
构造方法：无参，带参
成员方法：getXxx（），setXxx（），teach（）{}
抽象的老师类：
成员变量：name，age
构造方法：无参，带参
成员方法：getXxx（），setXxx（），teach（）；
实现：
使用：使用的是具体的类的对象
public abstract class Teacher {
private String name;
private int age;
public Teacher(){}
public Teacher(String name,int age){
this.age = age;
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void teach();
}public class Basic_Teacher extends Teacher {
public Basic_Teacher() {
}
public Basic_Teacher(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("基础班老师讲解JavaSE内容");
}
}public class Work_Teacher extends Teacher{
public Work_Teacher(){}
public Work_Teacher(String name,int age){
super(name,age);
}
@Override
public void teach() {
System.out.println("就业班教授JavaEE");
}
}public class TeacherDemo {
public static void main(String[] args) {
//使用具体的类的对象
Basic_Teacher a = new Basic_Teacher();
a.teach();
//多态形式
Teacher a1 = new Basic_Teacher();
a1.setAge(30);
a1.setName("林青霞");
System.out.println(a1.getName()+"..."+a1.getAge());
a1.teach();
System.out.println("----------");
a1 = new Basic_Teacher("林青霞",30);
a1.teach();
}
}输出结果：
基础班老师讲解JavaSE内容
林青霞...30
基础班老师讲解JavaSE内容
----------
基础班老师讲解JavaSE内容
接口：
接口特点：
A:定义接口使用的是interface关键字
B:类和接口之间是实现关系，用implement关键字表示
C:接口不能实例化
接口有没有其他的方式实例化呢
参照多态的方式使用实现类来实例化
D:接口的实现类
要么重写接口中的所有抽象方法，要么是一个抽象类
多态的几种形式：
具体类多态
抽象类多态
接口多态
public interface jumpping {
public abstract void jump();
}public class Cat implements jumpping{
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}public class InterfaceDemo {
public static void main(String[] args) {
//接口多态的形式实例化
jumpping j = new Cat();
j.jump();
}
}
输出结果：
猫可以跳高了
接口的成员特点：
成员变量：
有成员变量，且成员变量只能是常量
构造方法：
没有构造方法
成员方法：
有成员方法，且都是抽象的
默认修饰符：public abstract
object：是类层次结构的根类，所有类间接或是直接继承该类
类与类-类与接口-接口与接口
类与类：
继承关系，只能单继承，可以多层继承
类与接口：
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口
接口与接口：
继承关系，可以单继承，也可以多继承。
抽象类和接口的区别：
A：成员区别：
抽象类：
成员变量：可以是变量，也可以是常量
构造方法：有
成员方法：可以是抽象方法，也可以是非抽象方法
接口：
成员变量：只能是常量
成员方法：只能是抽象方法
B：关系区别
类与类：
继承关系，只能单继承，可以多层继承
类与接口：
实现关系，可以单实现，也可以多实现。
接口与接口：
继承关系，可以单继承，也可以多继承。
C:设计理念的区别
抽象类 被继承体现的是“is a” 其中定义的是继承体系的共性功能
接口 被实现体现的是“like a” 其中定义的是该体现的扩展功能
举例：
猫：动物
猫：跳高运动员
接口练习：
需求：
猫狗案例,让所有的猫狗具备跳高的额外功能
分析：从具体到抽象
猫：姓名，年龄，吃饭(){}
狗：姓名，年龄，吃饭(){}
发现了共性的内容，就提取了一个父类。
抽象动物类：
姓名，年龄，吃饭();
猫：继承动物类
狗：继承动物类
跳高的额外功能是一个扩展功能，所以应该定义接口实现。
跳高接口：
跳高();
猫：继承动物类,实现跳高接口
狗：继承动物类,实现跳高接口
实现：从抽象到具体
使用：使用的是具体的类的对象
public abstract class Animal {
private String name;
private int age;
public Animal() {}
public Animal(String name,int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
public interface Jumpping {
public abstract void jump();
}
public class Cat extends Animal implements Jumpping {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
public class InterfaceTest {
public static void main(String[] args) {
Cat c = new Cat();
c.setName("加菲猫");
c.setAge(3);
System.out.println(c.getName()+"---"+c.getAge());
c.eat();
c.jump();
System.out.println("-------------------------");
Cat c2 = new Cat("加菲猫",3);
System.out.println(c2.getName()+"---"+c2.getAge());
c2.eat();
c2.jump();
}
}
接口练习2运动员和教练案例：
分析图如下：
代码如下：
public abstract class Person {
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.age = age;
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}public abstract class Player extends Person{
public Player(){}
public Player(String name, int age) {
super(name,age);
}
public abstract void learn();
}public class Basketball_Player extends Player implements Learn_English{
public Basketball_Player(){}
public Basketball_Player(String name,int age){
super(name,age);
}
@Override
public void learn() {
System.out.println("篮球运动员学习打篮球");
}
@Override
public void eat() {
System.out.println("篮球运动员吃羊肉");
}
@Override
public void speak() {
System.out.println("篮球运动员说英语");
}
}public interface Learn_English {
public abstract void speak();
}public class Demo {
public static void main(String[] args) {
//测试运动员
Basketball_Player bp = new Basketball_Player();
bp.setAge(33);
bp.setName("姚明");
System.out.println(bp.getName()+"---"+bp.getAge());
bp.eat();
bp.learn();
bp.speak();
}
}输出结果：
姚明---33
篮球运动员吃羊肉
篮球运动员学习打篮球
篮球运动员说英语
包的概述和注意事项：
包：其实就是文件夹
作用：对类进行分类管理
举例：
学生：增加 删除 修改 查询
老师：增加 删除 修改 查询
...
方案1：按照功能分
方案2：按照模块分
包的定义格式：
package 包名；
如果是多级包用，隔开即可
注意事项：
A：package必须是第一条可执行语句
B：package语句在一个Java文件中只能有一个
导包：
如何导包：
在类前用import
格式：import 包名；
权限修饰符：
本类 同一个包下（子类和无关类） 不同包下（子类） 不同包下（无关类）
private： Y
默认： Y Y
protected： Y Y Y
public： Y Y Y Y
632
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
