知识点
1. 接口
2. package、import、class
3. 修饰符
4. 5种内部类
5. Eclipse常用快捷键
6. Object类
重点
1.接口
- 什么是接口：就是指java的interface,接口就是定义一些规则
- 接口的特点
a:接口用关键字interface表示
interface 接口名{}
b:类实现接口用implements表示
class 类名 implements 接口名{}
c:接口不能实例化
按照多态的方式来实例化
接口 变量名 = new 实现类();
d:接口的子类
可以是抽象类，但意义不大
可以是具体类，要重写接口中的所有方法
2.类与类，类与接口，接口与接口的关系讲解
-
类与类:
继承关系，只能是单继承，可以多层继承 -
类与接口
实现关系，可以单实现，也可以多实现
并且还可以在继承一个类的同时实现多个接口 -
接口与接口
继承关系，可以单继承，也可以多继承
3.package关键字
package其实就是一个文件夹，它用于代码的分模块
package的命令规则是域名的倒写+模块名称
eg:www.baidu.com
com.baidu.student
com.baidu.teacher
4.包的注意事项
1.package必须放在代码的第一行
2.导入一个包的类有两种方法
com.baidu.model.Student;只导入一个类
com.baidu.model.*;导入这个包的所有类
3.创建对象的另一个方式
以前:Student stu = new Student();
现在可以使用: com.baidu.model.Student stu = new com.baidu.model.Student();
5.import关键字
1.import用来导入其它包的类
2.import必须放在package的下面
6.用在类身上的修饰符
1.如果一个类不写任何的修饰符(default),代表这个类，只能在当前包被访问
2.如果一个类写了public,代表这个类，任何人都能访问，public类就是共享的
3.如果一个类声明为final,代表这个类没有子类，不能被继承
4.如果一个类声明为abstract抽象，代表这个类不能new,只能由子类来继承抽象并，并且要实现抽象类的抽象方法
7.用在属性上的修饰符
1.如果一个属性声明为private，代表这个属性只能在当前类中使用
2.如果一个属性什么都不声明，代表是默认的,表示在同一个包中能被访问，其它包不访问这个属性
3.属性声明为protected，代表的意思先放着。。。后面讲
4.属性声明为public,代表任何地方都可以访问这个属性
5.属性声明为static,代表是一个静态属性，访问的时候，通过类名访问
6.属性声明为final,代表这个属性变成了"常量",如果是常量，最好一旦声明就赋值
8.用在构造方法上的修饰符
1.如果构造方法声明为public,代表这个类的外面可以调用构造方法来创建对象
2.如果构造方法声明为private,代表这个类的外面不可以调用构造方法来创建对象
但是这个类的内部是可以调用构造方
3.构造方法声明为protected，很少用，不用学…
4.构造方法前面不写，代表默认，同一个包内可以调用构造方法
9.用在方法上的修饰符
1.如果方法声明为private,代表这个方法只能在当前类中使用
2.如果方法声明不写权限，就是默认的权限，代表这个方法在同一个包中可能被访问，其它包不能访问
3.如果方法声明为protected,先放着，后面讲
4.如果方法声明为public,代表任何地方都可以访问这个方法
5.如果方法声明为static,代表静态方法，通过类名调用方法
6.如果方法声明为final,这个方法不能被 重写/覆盖 override
7.如果方法声明为abstract,这个方法需要被子类实现
10.修饰符配合使用
成员方法：
- public static
- public abstract
- public final
成员变量：public static final
abstract class A{
//公共的静态常量…
public static final int MAX_INT = 140;//最大的数字
//这个方法任何人都能访问，使用静态方法访问
public static void test1(){
System.out.println("...");
}
//这个方法是公共，需要子类实现
public abstract void test2();
//这个方法也是公共，任何人都能访问，但是不能被子类重写
public final void test3(){
System.out.println("....");
}
}
11.protected 受保护的
- protected修饰的方法只能在当前包中访问，或者子类访问
12.内部类（*）
类里面再声明类
- 五种分类
- 默认内部类
class Outer{
private int a = 12;
class Inner{
public void test2(){
//"内部类"可以直接访问"外部类"的成员，包括私有。
System.out.println("内部类访问外部的变量a=" + a);
}
}
}
- 私有内部类
class Outer{
private int a = 12;
private class Inner{
public void test2(){
System.out.println("内部类访问外部的变量a=" + a);
}
}
public void test1(){
Inner inner = new Inner();
inner.test2();
}
}
- 静态内部类
class Outer{
private int a = 12;
static class Inner{
public void test2(){
System.out.println("内部类访问外部的变量a=" + a);
}
}
}
- 局部内部类
class Outer{
public void test1(){
final int a = 10;//局部变量
class Inner{//局部内部类
public void test2(){
System.out.println(a);
}
}
Inner inner = new Inner();
inner.test2();
}
}
- 匿名内部类
a抽象类的匿名内部类
b接口的匿名内部类
c new 抽象类 或者接口，都必须实现里面的所有方法
13.抽象类与接口的区别
/* 成员区别
1.抽象类:
*属性：可以变量，也可以常量
*构造方法：有
*成员方法：可以抽象，也可以非抽象
2.接口：
*属性：只可以常量
成员方法:只可以抽象
3.关系区别
类与类: 继承关系，单继承
类与接口: 实现关系，单实现和多实现都可以
接口与接口: 继承关系，单继承和多继承
4.设计理念区别
抽象类 抽象类中定义的是该继承体系的共性功能
接口 接口中定义的是该继承体系的扩展功能/
public class Demo01 {
public static void main(String[] args) {
System.out.println(AnimalInteface.MAX_LEGS);
}
}
abstract class Animal{
String name;//变量
final int MAX_LEGS = 4;//常量
public Animal(String name) {
super();
this.name = name;
}
//非抽象的方法
public void say(){
}
//抽象方法
public abstract void speak();
}
interface AnimalInteface{
//String name;//接口不能写变量
final int MAX_LEGS = 4;//接口中只能写常量，默认加了静态
public void say();//默认就是抽象方法，而且接口只能写抽象方法
//接口的方法不能写实现
/*public void speak(){
}*/
}
14.Eclipse快捷键
//1.ctrl + n :新建文件
//2.ctr + shift + f:代码格式化
//3.ctrl + shift + o :快速导包
//4.ctrl + shift + / :多行注释
//5.ctrl + shift + \ :取消多行注释
//6.ctrl + / ：单行注释
//7.alt + 上、下键：代码移动
//8.ctrl + 鼠标点击：查看源码
//9.Fn + F3 看源码
//10.ctrl + shift + t :查找类
//11.ctrl + o: 找类的方法
//12.ctrl + 1: 快速修复问题
//13.ctrl + d: 删除代码
//14.alt + shift + m:抽取方法
//15.alt + shift + r:改名
//16.添加自己的内容辅助键(alt + /)
15.生成jar包的导入jar包到项目
jar的作用：jar就是把.class文件进行压缩
在项目中的使用:别人写好的功能进行打包，我们使用的时候，
只需要知识方法怎么用就行了，至用方法内部的实现(算法)我们不用理会
/***
- 1.如何生成一个jar包
- 选中项目 – 右键 – Export – Java – Jar – 自己指定一个路径和一个名称 - Finish
- 2.使用jar包
- 》在项目中创建一个lib文件夹(lib-library类库)
- 》把jar包放在lib下
- 》右键.jar - bulid path
*/
16. Object
1》Object类的概述
1.Object是类层次结构的根类
2.所有类都直接或者间接的继承Object类
3.Object类的构造方法：public Object（）
4.子类的构造方法默认访问的是父类的无参构造方法
2》Object的hashCode方法
1.Object有一个方法 public int hashCode（）
2.方法返回对象的哈希码值，默认情况下该方法会根据对象的地址来计算
3.不同对象的hashCode()一般来说不会相同，但同一个对象的hashcode值肯定是相同的
4.hashCode不是对象的实际地址值，可以理解为逻辑地址值
3》Object的getClass方法
1.public final class getClass()
2.返回此object运行时类
3.可以通过class类中的一个方法，获取对象的真实类的全名称
练习题
1.员工抽象类
1.程序员、项目经理
2.程序员：名字，工号，工资，项目经理有个特殊奖金
abstract class Employee{
String name;
String id;
double salary;
//3个构造方法
//say方法
public abstract void say();
}
class Progremmer extends Employee{
public void say(){
{
System.out.println( name);
System.out.println( id);
System.out.println( salary);
}
}
}
class ProjectMananger extends Employee{
double bonuses;
//构造方法（4个参数）｛
调用父类的3个参数构造方法
this.bonuses = bonuses;
｝
public void say(){
{
System.out.println( name);
System.out.println( id);
System.out.println( salary);
System.out.println( bonuses);
}
}
//比较好的写法
class ProjectMananger extends Progremmer{
double bonuses;
//构造方法（4个参数）｛
调用父类的3个参数构造方法
this.bonuses = bonuses;
｝
public void say(){
{
supper.say();
System.out.println( bonuses);
}
}
2.抽象类和接口综合案例
- 共性的东西写抽象类
- 非共性可以写在接口
/***
* 结论：
* 如果一个类，即继承抽象类，又实现接口，最好不要用多态的写法
* 如果是多态的写法，接口的方法不能调用,或者说抽象类的方法不能调用
**/
public class Demo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//练习-抽象类与接口综合案例
/* 动物类:姓名，年龄，吃饭，睡觉
猫和狗
动物培训接口:跳高*/
//使用多态来用类
//Animal cat = new Cat();//多态：抽象类指向子类对象
//JumpInterface cat = new Cat();//多态：接口指向子类对象
Cat cat = new Cat();
cat.name = "小花";
cat.age = 1;
cat.eat();
cat.sleep();
cat.jump();
System.out.println("=============");
Animal dog = new Dog();
dog.name = "小黑";
dog.age = 3;
dog.eat();
dog.sleep();
}
}
//抽象类声明的是共同属性和行为
abstract class Animal{
String name;
int age;
public abstract void eat();
public abstract void sleep();
}
class Cat extends Animal implements JumpInterface{
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("猫躺着睡...");
}
@Override
public void jump() {
System.out.println("猫跳火圈...");
}
}
class Dog extends Animal{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("狗啃骨头...");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("狗趴着睡...");
}
}
//跳高不是共性，所以声明到一个接口中,不放在抽象类
interface JumpInterface{
public void jump();
}
3.某女星和某干爹的例子讲解
eg.一个人只能有一个亲爹，可以有多个干爹
如同一个类只能继承一个父类，可以实现多个接口
/***
* 案例是帮助大家更好的理解
* 1.类与类 为什么只能是单继承
* 2.类与接口 可以多实现
* @author zx
*
*/
public class Demo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//某女星和某干爹的例子
刘亦菲 lyf = new 刘亦菲();
lyf.drive();
lyf.东成西就();
lyf.芳华();
}
}
class 亲爹{
public void drive(){
System.out.println("开着三轮车...");
}
}
interface 张艺谋干爹{
public void 东成西就();
}
interface 冯小刚干爹{
public void 芳华();
}
class 刘亦菲 extends 亲爹 implements 张艺谋干爹,冯小刚干爹{
@Override
public void 东成西就() {
System.out.println("恭喜，张艺谋干爹给你演东成西就主角...");
}
@Override
public void 芳华() {
System.out.println("恭喜，冯小刚干爹给你演芳华主角...");
}
}
面试题
1.pacage,import,class,有没顺序？
a. package只能有一个，必须放在java文件的第一行
b. import只能放在package的下面,多个import应放在一起
c. class 放在 package 或者import的下面
2.局部内部类访问局部变量时，变量要加final修饰，为什么？
jdk1.8，不加final代码不会报错，jdk1.7以下的版本不写final会报错
其实就是在jdk1.8的环境下，系统帮你默认添加了final关键字
public class Demo01 {
public static void main(String[] args) {
Outer outer = new Outer();
outer.test1();
}
}
/**
* 1.局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
* 2.jdk1.8，不加final代码不会报错，jdk1.7以下的版本不写final会报错
* */
class Outer{
public void test1(){
final int a = 10;//局部变量
class Inner{//局部内部类
public void test2(){
System.out.println(a);
}
}
Inner inner = new Inner();
inner.test2();
}
}
3.内部类面试题
interface Inter {
void show();
}
class A implements Inter{
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("HelloWord");
}
}
class Outer {
//补齐代码
//第一种写法
/*public static A method(){
return new A();
}*/
/*public static Inter method(){
return new A();
}*/
//第二种写法：接口指向匿名内部类对象
//方法的返回值类型是接口
public static Inter method(){
return new Inter() {
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("HelloWord");
}
};
}
}
class OuterDemo {
public static void main(String[] args){
Outer.method().show();
}
}
总结
今天带妹学习了面向对象的接口、4种修饰符、5种内部类等知识点。说实话，Java这一块的内容有点绕，特别是内部类里，种类繁多，如果该类或者方法被static、abstract、final、private等修饰符修饰，实例化对象也有变化。不过知识循序渐进的，理解哪些是类属性，哪些是对象属性，就好做了。抽象类和接口的区别在于，抽象类-属性：可以是变量，也可以常量，构造方法：有；成员方法：可以抽象，也可以非抽象。而接口：属性：只可以常量，成员方法:只可以抽象抽象类拥有属性。另外对数据存储，栈区、堆区、方法区有深一步的理解，便于逻辑思维的养成。最后希望大家要坚持敲代码，练出码感。
