学习目标

描述final修饰的类的特点//是一个最终类不能被继承,是一个太监类
描述final修饰的方法的特点//是一个最终方法,可以被继承使用,但是不能被重写
描述final修饰的变量的特点//是一个常量,值不能改变局部变量:定义在方法中的变量基本数据类型:值不能改变引用数据类型(数组,对象,集合...):地址值不能改变成员变量:定义在成员位置,类中方法外保证在创建对象前赋值1.可以定义变量的时候直接赋值2.可以使用构造方法给变量赋值
能够掌握static关键字修饰的变量调用方式类名.静态成员变量public class Person{static int a = 10;}Person.a;
能够掌握static关键字修饰的方法调用方式类名.静态成员方法(参数);public class Person{public static void show(int a){}}Person.show(10);
能够写出接口的定义格式public interface 接口名{抽象方法 public abstract 返回值类型 方法名(参数);默认方法 public default 返回值类型 方法名(参数){方法体}静态方法 public static 返回值类型 方法名(参数){方法体}}
能够写出接口的实现格式public class 实现类 implements 接口{}
能够说出接口中的成员特点变量:接口中的变量都是常量,有固定的修饰符 public static final int AAA = 10;方法:抽象方法(需实现类重写) 默认方法(实现类可以选择性重写) 静态方法(不能重写,使用接口名直接调用)接口中没有构造方法,不能创建对象

一.final关键字

1.final修饰的类

package com.itheima.demo01finalClass;public class Ye {
}

package com.itheima.demo01finalClass;/*final修饰的类:是一个最终类,不能被继承;其他的使用方式不变(继承其他的类,创建对象使用...)简单记:太监类*/
public final class Fu extends Ye{
}

package com.itheima.demo01finalClass;/*Cannot inherit from final 'com.itheima.demo01finalClass.Fu'被final修饰的类,不能被继承*/
/*public class Zi extends Fu{
}*/

package com.itheima.demo01finalClass;public class Demo01 {public static void main(String[] args) {Fu fu = new Fu();}
}

2.final修饰的方法

package com.itheima.demo02finalMethod;/*final修饰的方法:是一个最终方法,可以被继承使用,但是不能被重写*/
public class Fu {public void show01(){System.out.println("Fu类没有被final修饰的show01方法");}public final void show02(){System.out.println("Fu类被final修饰的show02方法");}
}

package com.itheima.demo02finalMethod;public class Zi extends Fu{public void show01(){System.out.println("Zi类重写Fu类没有被final修饰的show01方法");}/*'show02()' cannot override 'show02()' in 'com.itheima.demo02finalMethod.Fu'; overridden method is final子类不能重写父类被final修饰的方法*//*public final void show02(){System.out.println("Fu类被final修饰的show02方法");}*/
}

package com.itheima.demo02finalMethod;public class Demo01 {public static void main(String[] args) {Zi zi = new Zi();zi.show01();//调用的是子类重写后的show01方法zi.show02();//调用子类继承自父类的final修饰的方法}
}

3.final修饰的变量

局部变量:是一个常量,值不能改变

package com.itheima.demo03finalVariable;/*final修饰的变量:是一个常量,值不能改变局部变量:定义在方法中的变量(语句中for)final修饰符是局部变量唯一的修饰符*/
public class Demo01 {public static void main(String[] args) {/*final修饰的局部变量:是一个常量,值不能改变(一次赋值,终身不变)基本数据类型(4类8种):值不能改变*/final int a = 10;//a = 20;//Cannot assign a value to final variable 'a'/*引用数据类型(数组,类,集合...):地址值不能改变对象中的内容是可以改变的(成员变量的值,数组中的元素,集合中的元素...)*/final Person p1 = new Person("张三",20);System.out.println(p1);//com.itheima.demo03finalVariable.Person@4554617c//p1 = new Person("李四",30);//Cannot assign a value to final variable 'p1'System.out.println(p1);//com.itheima.demo03finalVariable.Person@74a14482//p1 = null;//Cannot assign a value to final variable 'p1'p1.setAge(30);System.out.println(p1);//com.itheima.demo03finalVariable.Person@4554617c}
}

package com.itheima.demo03finalVariable;public class Person {private String name;private int age;public Person() {}public Person(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;}
}

成员变量:必须在创建对象前赋值

package com.itheima.demo03finalVariable;/*final修饰的成员变量:是一个常量,值不能改变特点:特殊记忆final修饰的成员变量必须在创建对象前赋值(规定)注意:1.成员变量的默认值(String=>null,int==>0,doble=>0.0,boolean==>false),不是final修饰的成员变量的值,必须赋一个具体值2.赋值的方式:a.直接赋值:定义变量,直接给变量赋值b.使用构造方法赋值,构造方法是创建对象前执行无论哪种赋值方式,只能赋值一次3.常量的命名规则:一般都使用大写字母final int  AAA_BBB_CCC = 10;*/
public class Student {//final int a;//Variable 'a' might not have been initialized//a.直接赋值:定义变量,直接给变量赋值final int b = 10;final int c;final String d = null;//b.使用构造方法赋值,构造方法是创建对象前执行public Student() {c = 20;//b = 100;//Cannot assign a value to final variable 'b' 无论哪种赋值方式,只能赋值一次}public Student(int e){c=e;}
}

二.static关键字

1.static关键字概述(了解)

2.static关键字的使用(使用)

package com.itheima.demo04static;/*定义每个学生特有的属性(非静态):姓名,年龄定义每个学生共享的属性(静态):国家*/
public class Student {String name;int age;static String country = "中国";
}

package com.itheima.demo04static;public class Demo01Student {public static void main(String[] args) {//创建Student对象,给对象的属性赋值Student s1 = new Student();s1.name = "张三";s1.age = 18;System.out.println(s1.name+"\t"+s1.age);System.out.println(s1.country);Student s2 = new Student();s2.name = "李四";s2.age = 19;System.out.println(s2.name+"\t"+s2.age);System.out.println(s2.country);//改变country的值s2.country = "中华人民共和国";System.out.println(s1.country);System.out.println(s2.country);}
}

3.static修饰的静态成员的使用方式(重点)

package com.itheima.demo05static;/*定义每个学生特有的成员(非静态)只有一种使用方式:创建对象,访问属性,调用方法定义每个学生共享的成员(静态)有两种使用方式:1.创建对象,访问属性,调用方法(不推荐,占用内存,效率低)2.静态的成员属于类,所以我们可以通过类名直接使用类名.静态成员变量类名.静态的成员方法(参数);*/
public class Student {//定义非静态的成员变量int a = 10;//定义静态成员变量static int b = 20;//定义非静态的成员方法public void show01(){System.out.println("Student类的非静态show01方法!");}//定义静态的成员方法public static void show02(){System.out.println("Student类的静态show02方法!");}
}

package com.itheima.demo05static;public class Demo01Student {public static void main(String[] args) {//创建Student对象Student s = new Student();System.out.println(s.a);System.out.println(s.b);s.show01();s.show02();//静态的成员,通过类名可以直接使用System.out.println(Student.b);Student.show02();Student.b = 200;System.out.println(Student.b);Demo01Student.method();//同一个类中,使用静态的成员,可以省略类名method();}public static void method(){System.out.println("静态的method方法!");}
}

4.static的内存图解(了解)

三.接口

1.接口概述(了解)

接口:是引用数据类型的一种,是功能的集合(接口中定义的都是方法)接口中不能定义变量,可以定义常量(很少使用)
定义接口使用的也是.java文件;编译生成的也是.class文件
定义接口使用关键字interface
定义格式:修饰符 interface 接口名{抽象方法;(jdk7)重点默认方法;(jdk8)静态方法;(jdk8)}

2.定义使用含有抽象方法的接口(重点)

package com.itheima.demo06interface;/*定义使用含有抽象方法的接口(重点)抽象方法:没有方法体,被abstract修饰的方法定义格式:public abstract 返回值类型 方法名(参数);注意:1.接口中的抽象方法修饰符是可以省略不写的,不写默认也是public abstract建议写出,增强阅读性-----------------------------接口的使用:1.接口是不能创建对象使用2.可以定义一个实现类,实现(继承)接口,重写接口中的抽象方法,创建实现类对象使用*/
public interface MyInter {//定义抽象方法//public abstract void show01();//abstract void show01();void show01();public abstract int show02();public abstract void show03(String s);
}

package com.itheima.demo06interface;/*定义接口的实现类使用格式:使用实现类实现接口,重写接口中的抽象方法public class 实现类名 implements 接口{重写接口中的抽象方法}注意:实现类似于继承,类实现接口,就可以继承接口中所有的非私有方法*/
public class MyInterImpl implements MyInter{@Overridepublic void show01() {System.out.println("实现类重写接口中的show01抽象方法!");}@Overridepublic int show02() {System.out.println("实现类重写接口中的show02抽象方法!");return 0;}@Overridepublic void show03(String s) {System.out.println("实现类重写接口中的show03抽象方法!"+s);}
}

package com.itheima.demo06interface;public class Demo01MyInter {public static void main(String[] args) {//'MyInter' is abstract; cannot be instantiated 接口不能创建对象使用//MyInter my = new MyInter();//创建接口的实现类对象MyInterImpl my = new MyInterImpl();my.show01();my.show02();my.show03("张靓颖");}
}

3.定义使用含有默认方法的接口(了解)

package com.itheima.demo07defaultInterface;/*定义使用含有默认方法的接口(了解):很少自己定义,看java底层源码能看到定义格式:修饰符 default 返回值类型 方法名(参数){方法体;}注意:默认方法的修饰符default是不能省略*/
public interface MyInter {public default void show01(){System.out.println("MyInter接口中的默认show01方法!");}public default void show02(){System.out.println("MyInter接口中的默认show02方法!");}
}

package com.itheima.demo07defaultInterface;/*含有默认方法的接口的使用:定义实现类,实现接口,选择性的重写默认方法,创建实现类对象使用重写了默认方法:使用实现类重写后的方法没有重写默认方法:使用继承自接口中的默认方法注意:实现类重写接口中的默认方法,去掉default关键字*/
public class MyInterImpl implements MyInter{@Overridepublic void show01() {System.out.println("实现类重写了MyInter接口中的默认show01方法!");}
}

package com.itheima.demo07defaultInterface;public class Demo01 {public static void main(String[] args) {//创建接口的实现类对象使用MyInterImpl my = new MyInterImpl();my.show01();//实现类重写的my.show02();//继承自接口的}
}

4.定义使用含有静态方法的接口(了解)

package com.itheima.demo08staticInteface;/*定义使用含有静态方法的接口(了解):很少自己定义,看java底层源码能看到定义格式:修饰符 static 返回值类型 方法名(参数){方法体;}注意:定义静态方法不能省略static关键字定义含有静态方法的接口的是用:静态成员属于接口(类)本身,所以可以通过接口名.方法名(参数)直接使用*/
public interface MyInter {public static void show01(){System.out.println("MyInter接口中的静态show01方法!");}public static String show02(int a){System.out.println("MyInter接口中的静态show02方法!"+a);return "哈哈";}
}

package com.itheima.demo08staticInteface;public class MyInterImpl implements MyInter {/*能重写静态方法吗?静态方法是不能重写的,属于类|接口本身,不能被子类|实现类重写在是实现类定义了静态方法,属于实现类本身*///@Overridepublic static void show01(){System.out.println("MyInter接口中的静态show01方法!");}
}

package com.itheima.demo08staticInteface;public class Demo01 {public static void main(String[] args) {//通过接口名.方法名(参数)直接调用接口中的静态方法MyInter.show01();String s = MyInter.show02(10);System.out.println(s);//MyInterImpl my = new MyInterImpl();//my.show01();//Static method may be invoked on containing interface class only}
}

5.接口的多实现

含有抽象方法接口的多实现(重点)

package com.itheima.demo09abstractInterface;//定义含有抽象方法的接口
public interface A {public abstract void a();public abstract void show();
}

package com.itheima.demo09abstractInterface;//定义含有抽象方法的接口
public interface B {public abstract void b();public abstract void show();
}

package com.itheima.demo09abstractInterface;/*接口的多实现:类可以同时实现多个接口格式:public class 实现类 implements 接口1,接口2,接口3....接口n{重写所有接口中的抽象方法}注意:接口中含有抽象方法,实现类需要重写所有接口的抽象方法如果接口中有同名的抽象方法,实现类只重写一个就可以了不会产生不确定性,抽象方法没有方法体*/
public class AandBImpl implements A,B{@Overridepublic void a() {System.out.println("实现类重写A接口中的抽象a方法!");}@Overridepublic void b() {System.out.println("实现类重写B接口中的抽象b方法!");}@Overridepublic void show() {System.out.println("实现类重写A接口和B接口中的抽象show方法!");}
}

package com.itheima.demo09abstractInterface;public class Demo01 {public static void main(String[] args) {//创建接口的实现类对象使用AandBImpl ab = new AandBImpl();ab.a();ab.b();ab.show();}
}

含有默认方法接口的多实现(了解)

package com.itheima.demo10defaultInterface;//定义含有默认方法的接口
public interface A {public default void a(){System.out.println("A接口中的默认a方法!");}public default void show(){System.out.println("A接口中的默认show方法!");}
}

package com.itheima.demo10defaultInterface;//定义含有默认方法的接口
public interface B {public default void b(){System.out.println("B接口中的默认b方法!");}public default void show(){System.out.println("B接口中的默认show方法!");}
}

package com.itheima.demo10defaultInterface;/*接口的多实现:类实现含有默认方法的多个接口格式:public class 实现类 implements 接口1,接口2,接口3....接口n{}注意:1.如果接口中的默认方法不重复,实现类可以选择重写或者不重写默认方法重写:使用实现类重写的不重写:使用继承自接口的2.如果多个接口中默认方法有重复的,实现类必须重写这个重复的默认方法有不确定性,实现类不知道使用继承自哪个接口的默认方法,重写之后使用自己的*/
public class AandBImpl implements A,B{@Overridepublic void show() {System.out.println("实现类重写A接口和B接口中默认的show方法!");}
}

package com.itheima.demo10defaultInterface;public class Demo01 {public static void main(String[] args) {//定义接口的是实现类对象AandBImpl ab = new AandBImpl();ab.a();//继承自A接口中的ab.b();//继承自B接口中的ab.show();//实现类自己重写的}
}

含有静态方法接口的多实现(了解)

package com.itheima.demo11staticInterface;//定义含有静态方法的接口
public interface A {public static void a(){System.out.println("A接口中的静态a方法!");}public static void show(){System.out.println("A接口中的静态show方法!");}
}

package com.itheima.demo11staticInterface;//定义含有静态方法的接口
public interface B {public static void b(){System.out.println("B接口中的静态b方法!");}public static void show(){System.out.println("B接口中的静态show方法!");}
}

package com.itheima.demo11staticInterface;/*接口的多实现:实现类实现含有静态方法的多个接口格式:public class 实现类 implements 接口1,接口2,接口3....接口n{}注意:1.实现类实现含有静态方法的接口,没有意义;静态方法实现类不能继承,也不能重写2.接口中静态方法有重复的,不会冲突,静态方法属于每个接口本身*/
public class AandBImpl implements A,B{
}

package com.itheima.demo11staticInterface;public class Demo01 {public static void main(String[] args) {//使用接口名.方法名(参数)调用接口中的静态方法A.a();A.show();B.b();B.show();}
}

6.类继承类的同时实现多个接口(重点)

package com.itheima.demo12extendsAndImplements;public class QinDie {//定义普通方法public void kaoQingHua(){System.out.println("亲爹希望孩子考上清华大学!");}
}

package com.itheima.demo12extendsAndImplements;public interface GanDie1 {public abstract void kaoBeiDa();
}

package com.itheima.demo12extendsAndImplements;public interface GanDie2 {public abstract void findGF();public default void kaoQingHua(){System.out.println("干爹2希望孩子考上清华大学!");}
}

package com.itheima.demo12extendsAndImplements;/*一个类可以在继承父类的同时,实现多个接口格式:public class 子类 extends 父类 implements 接口1,接口2,....接口n{}注意:1.父类|接口中有抽象方法,子类需要全部重写2.父类中的普通方法和接口中的默认方法重复了,子类优先使用父类的*/
public class Zi extends QinDie implements GanDie1,GanDie2{@Overridepublic void kaoBeiDa() {System.out.println("Zi类重写了GanDie1的kaoBeiDa的抽象方法!");}@Overridepublic void findGF() {System.out.println("Zi类重写了GanDie2的findGF抽象方法!");}
}

package com.itheima.demo12extendsAndImplements;public class Demo01 {public static void main(String[] args) {//创建Zi类对象Zi zi = new Zi();zi.kaoBeiDa();zi.findGF();zi.kaoQingHua();//亲爹希望孩子考上清华大学!}
}

7.接口的多继承(使用)

package com.itheima.demo13interface;public interface A {public abstract void a();public default void show(){System.out.println("A接口中的默认show方法!");}
}

package com.itheima.demo13interface;public interface B {public abstract void b();public default void show(){System.out.println("B接口中的默认show方法!");}
}

package com.itheima.demo13interface;/*类与类之间:继承关系public class 子类 extends 父类{ }类与接口之间:实现关系public class 实现类 implements 接口,接口...{ }接口与接口之间:继承关系public interface 子接口 extends 父接口1,父接口2,...{ }注意:子接口继承多个父接口,相当于求接口的并集子接口包含所有父接口中的方法(抽象的,默认的)父接口中的默认方法有重复的,子接口必须重写这个默认方法,为了区分使用的是哪个默认方法,重写之后使用自己的*/
public interface C extends A,B{public abstract void c();@Overridepublic default void show() {System.out.println("C接口重写A接口和B接口中的默认show方法!");}
}

package com.itheima.demo13interface;/*CImpl实现类实现了C接口,就相当于同时实现了A,B,C三个接口实现类需要重写3个接口中所有的抽象方法*/
public class CImpl implements C{@Overridepublic void c() {System.out.println("实现类重写了C接口中抽象c方法");}@Overridepublic void a() {System.out.println("实现类重写了A接口中抽象a方法");}@Overridepublic void b() {System.out.println("实现类重写了B接口中抽象b方法");}
}

package com.itheima.demo13interface;public class Demo01 {public static void main(String[] args) {//创建接口的实现类对象CImpl c = new CImpl();c.a();c.b();c.c();c.show();}
}

8.接口中其他成员的特点(使用)

package com.itheima.demo14interface;/*接口中其他成员的特点(使用)1.接口中是无法定义成员变量的,但是可以定义常量,常量的值不能改变默认使用的修饰符public static final,接口中的常量修饰符可以省略不写,默认默认也是public static final常量的命名规则:所有的单词都要大写,多个单词之间使用下划线连接AAA_BBB_CCC定义一些常用的常量:公司的名称:"江苏省传智播客股份有限公司北京分公司"公司的网址: www.itcast.cn    www.itheima.com公司地址: 昌平区建材城西路金燕龙办公楼一层2.接口中,没有构造方法,不能创建对象3.接口中,没有静态代码块(讲代码块的时候在说)*/
public interface MyInter {String NAME = "江苏省传智播客股份有限公司北京分公司";public static final String WEB = "www.itcast.cn";public static final String ADDRESS = "昌平区建材城西路金燕龙办公楼一层";
}

package com.itheima.demo14interface;public class Demo01 {public static void main(String[] args) {//通过接口名访问接口中的常量,接口中的常量是被static修饰的System.out.println(MyInter.NAME);System.out.println(MyInter.WEB);System.out.println(MyInter.ADDRESS);//Cannot assign a value to final variable 'ADDRESS' 常量的值是不能改变的//MyInter.ADDRESS = "昌平区建材城西路金燕龙办公楼一层";System.out.println(Math.PI);}
}

9.接口和抽象类的区别(重点)

package com.itheima.demo15test;//缉毒接口
public interface JiDu {//缉毒功能public abstract void jiDu();
}

package com.itheima.demo15test;//牧羊接口
public interface MuYang {//牧羊功能public abstract void muYang();
}

package com.itheima.demo15test;//犬科类
public abstract class Quan {//姓名private String name;//年龄private int age;//吼叫public abstract void houJiao();//吃饭public abstract void eat();//睡觉public abstract void sleep();public Quan() {}public Quan(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;}
}

package com.itheima.demo15test;//京巴类
public class JingBa extends Quan {public JingBa() {}public JingBa(String name, int age) {super(name, age);//为了给成员变量name和age在创建对象的同时赋值}@Overridepublic void houJiao() {System.out.println("京巴在旺旺的叫!");}@Overridepublic void eat() {System.out.println("京巴吃的很少!");}@Overridepublic void sleep() {System.out.println("京巴趴着睡!");}
}

package com.itheima.demo15test;//缉毒犬类
public class JiDuQuan extends Quan implements JiDu{@Overridepublic void jiDu() {System.out.println("缉毒犬正在缉毒!");}@Overridepublic void houJiao() {System.out.println("缉毒犬嗷嗷的叫!");}@Overridepublic void eat() {System.out.println("缉毒犬吃皇家狗粮!");}@Overridepublic void sleep() {System.out.println("缉毒犬站着睡!");}
}

package com.itheima.demo15test;//牧羊犬
public class MuYangQuan extends Quan implements MuYang,JiDu {@Overridepublic void jiDu() {System.out.println("牧羊犬在缉毒!");}@Overridepublic void muYang() {System.out.println("牧羊犬在放羊!");}@Overridepublic void houJiao() {System.out.println("牧羊犬在叫唤!");}@Overridepublic void eat() {System.out.println("牧羊犬在吃羊!");}@Overridepublic void sleep() {System.out.println("牧羊犬在羊圈睡觉!");}
}

package com.itheima.demo15test;public class Demo01 {public static void main(String[] args) {//创建一个京巴对象JingBa jingBa = new JingBa("旺财",5);jingBa.eat();jingBa.sleep();jingBa.houJiao();System.out.println(jingBa.getName()+"\t"+jingBa.getAge());//创建缉毒犬对象JiDuQuan jiDuQuan = new JiDuQuan();jiDuQuan.eat();jiDuQuan.sleep();jiDuQuan.houJiao();jiDuQuan.jiDu();//创建牧羊犬对象MuYangQuan muYangQuan = new MuYangQuan();muYangQuan.eat();muYangQuan.sleep();muYangQuan.houJiao();muYangQuan.muYang();muYangQuan.jiDu();}
}