Java面向对象03

第1章 final和static关键字

1.1 final关键字的概述及特点

• final关键字是最终的意思，可以修饰类，成员变量，成员方法。
– 修饰类，类不能被继承
– 修饰变量，变量就变成了常量，只能被赋值一次
– 修饰方法，方法不能被重写

1.2 static关键字的概述及特点

1.2.1 静态的概述
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

1.2.2 静态的特点
– 被类的所有对象共享
• 这也是我们判断是否使用静态关键字的条件
– 可以通过类名调用
– 优先于对象存在
– 随着类的加载而加载

1.2.3 案例代码二

```java
package com.itheima_01;

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

1.3 static方法的访问特点及注意事项

• 静态方法的访问特点
– 静态方法只能访问静态的成员变量和静态的成员方法
– 静态方法的注意事项
– 在静态方法中是没有this,super关键字的
• 静态的内容是随着类的加载而加载，this和super是随着对象的创建而存在。也就是说我的静态方法是优先于对象进内存的，那么先进内存的是不能访问后进内存的。

第2章 抽象类

2.1 抽象类概述
当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具回想前面我们的猫狗案例，提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal()来创建动物对象的，其实这是不对的。为什么呢?因为，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

2.2 抽象类的特点
抽象类和抽象方法必须用abstract关键字修饰
格式:
public abstract class 类名 {}
public abstract void eat();
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化
那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法

2.2.1 案例代码五

package com.itheima_02;
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("睡觉");
	}
}

2.3 抽象类的成员的特点
• 成员变量
– 可以是变量
– 也可以是常量
• 构造方法
– 有构造方法，但是不能实例化
– 那么，构造方法的作用是什么呢?
• 用于子类访问父类数据的初始化
• 成员方法
– 可以有抽象方法 限定子类必须完成某些动作
– 也可以有非抽象方法 提高代码复用性

第3章 接口的概述以及练习
3.1 接口的概述
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现。
3.2 接口的特点
• 接口用关键字interface表示
– 格式：public interface 接口名 {}
– 类实现接口用implements表示
• 格式：public class 类名 implements 接口名 {}
– 接口不能实例化
• 那么，接口如何实例化呢?
• 按照多态的方式，由具体的实现类实例化。其实这也是多态的一种，接口多态。
– 接口的实现类
• 要么是抽象类
要么重写接口中的所有抽象方法

3.2.1 案例代码八

package com.itheima_01;

public class InterfaceDemo {
	public static void main(String[] args) {
		//Jumpping j = new Jumpping();
		//接口多态的形式实例化
		Jumpping j = new Cat();
		j.jump();
	}
}

package com.itheima_01;

public class Cat implements Jumpping {

	@Override
	public void jump() {
		System.out.println("猫可以跳高了");
	}

}

package com.itheima_01;

public abstract class Dog implements Jumpping {

}

package com.itheima_01;
//定义了一个跳高的接口
public interface Jumpping {
	//抽象方法
	public abstract void jump();
}

3.3 接口的成员特点
• 成员变量
– 只能是常量
– 默认修饰符 public static final
• 构造方法
– 没有，因为接口主要是扩展功能的，而没有具体存在
• 成员方法
– 只能是抽象方法
– 默认修饰符 public abstract

3.4 类与类_类与接口_接口与接口的关系
• 类与类
– 继承关系，只能单继承，但是可以多层继承
• 类与接口
– 实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
• 接口与接口
– 继承关系，可以单继承，也可以多继承

3.4.1 案例代码十
package com.itheima_03;
/*

• 类与类：

•  继承关系，只能单继承，可以多层继承。
  

• 类与接口：

•  实现关系，可以单实现，也可以多实现。
  

•  还可以在继承一个类的同时实现多个接口。
  

• 接口与接口：

•  继承关系，可以单继承，也可以多继承。
  

*/
public class InterfaceDemo {

}

package com.itheima_03;

public interface Sister extends Father,Mother {

}

package com.itheima_03;

public class Son extends Object implements Father,Mother {

}

package com.itheima_03;

public interface Mother {

}

package com.itheima_03;

public interface Father {

}

3.5 抽象类与接口的区别
• 成员区别
抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法
接口 常量;抽象方法
• 关系区别
类与类 继承，单继承
类与接口 实现，单实现，多实现
接口与接口 继承，单继承，多继承
• 设计理念区别
抽象类 被继承体现的是：”is a”的关系。共性功能
接口 被实现体现的是：”like a”的关系。扩展功能

第4章 包的概述和权限修饰符

4.1 包的概述和注意事项
4.1.1 包的概述
– 其实就是文件夹
– 作用：对类进行分类管理
– 包的划分：
• 举例：
– 学生的增加，删除，修改，查询
– 老师的增加，删除，修改，查询
– 以及以后可能出现的其他的类的增加，删除，修改，查询
– 基本的划分：按照模块和功能分。
– 高级的划分：就业班做项目的时候你就能看到了。
4.1.2 定义包的格式
– package 包名;
• 多级包用.分开即可
– 注意事项：
• package语句必须是程序的第一条可执行的代码
• package语句在一个java文件中只能有一个
4.1.3 案例代码十四

package com.itheima;
//package com.itheima2;
/*
 * 包：其实就是文件夹。
 * 作用：就是对类进行分类管理。
 * 
 * 举例：
 * 		学生：增加，删除，修改，查询
 * 		老师：增加，删除，修改，查询
 * 		...
 * 
 * 		方案1：按照功能分
 * 			com.itheima.add
 * 				AddStudent
 * 				AddTeacher
 * 			com.itheima.delete
 * 				DeleteStudent
 * 				DeleteTeacher
 * 			...
 * 		方案2：按照模块分
 * 			com.itheima.student
 * 				AddStudent
 * 				DeleteStudent
 * 				...
 * 			com.itheima.teacher
 * 				AddTeacher
 * 				DeleteTeacher
 * 包的定义格式：
 * 		package 包名;
 * 		如果是多级包用.隔开即可
 * 注意事项：
 * 		A:package必须是程序的第一条可执行语句
 * 		B:package语句在一个java文件中只能有一个
 */
public class PackageDemo {

}

4.2 导包的格式及使用
4.2.1 导包概述
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
4.2.2 导包格式
– import 包名;

4.2.3 案例代码十五

package com.itheima;
/*
 * 导包：
 * 		import 包名;
 */
import cn.itcast.Teacher;

public class Test {
	public static void main(String[] args) {
		Student s = new Student();
		s.show();
		
		/*
		//我要使用Teacher下的method()方法
		//类不在同一个包下，使用的时候，要加类的全路径名称
		cn.itcast.Teacher t = new cn.itcast.Teacher();
		t.method();
		t.method();
		
		cn.itcast.Teacher t2 = new cn.itcast.Teacher();
		t2.method();
		//这样做太麻烦了，java就提供了一个导包的功能
		 * 
		 */
		
		Teacher t = new Teacher();
		t.method();
		
	}
}

package com.itheima;
public class Student {
	public void show() {
		System.out.println("show");
	}
}

package cn.itcast;
public class Teacher {
	public void method() {
		System.out.println("method");
	}
}