Javase进阶笔记-day02
学习目标
能够描述final修饰的类的特点
最终类(太监类),不能被继承
能够描述final修饰的方法的特点
最终方法,可以被继承,不能被重写
能够描述final修饰的变量的特点
是一个常量,值不能改变
能够掌握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;
方法:抽象方法(需实现类重写) 默认方法(实现类可以选择性重写) 静态方法(不能重写,使用接口名直接调用)
接口中没有构造方法,不能创建对象
能够说出多态的前提
//有子父类继承关系|有类和接口的实现关系(有爹)
能够写出多态的格式
//父类的类型 变量名 = new 子类对象();
Animal a = new Cat();
Animal a = new Dog();
Fu fu = new Zi();
//接口的类型 变量名 = new 实现类对象();
MyInter f = new MyInterImpl();
能够理解多态向上转型和向下转型
//1.向上转型:多态本身就是向上转型
格式:
父类的类型 变量名 = new 子类对象();
接口的类型 变量名 = new 实现类对象();
Animal a = new Cat();
a = new Dog();
好处:
扩展性强,可以赋值不同的子类对象,调用不同子类重写的方法
弊端:
无法使用子类特有的成员变量和成员方法
//2.向下转型:前提必须是多态,可以把父类的类型强制转换为子类类型(强转)
格式:
子类类型 变量名 = (子类类型)父类变量名;
Cat c = (Cat)a;
c.catchMouse();
好处:
可以使用子类特有的内容
一.final关键字
1.修饰类
package com.itheima.demo01finalClass;
/*
final关键字:最终
final修饰的类:是一个最终类,不能被继承(太监类)
final修饰的类:其他的使用方式不变
*/
public final class Fu{
}
package com.itheima.demo01finalClass;
//Cannot inherit from final 'com.itheima.demo01finalClass.Fu'
/*public class Zi extends Fu{
}*/
查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。
2.修饰方法
package com.itheima.demo02finalMethod;
/*
final修饰的方法:是一个最终方法,可以被继承使用,但是不能被子类重写
*/
public class Fu {
public void show01(){
System.out.println("Fu类的show01方法!");
}
public final void show02(){
System.out.println("Fu类被fianl修饰的show02方法!");
}
}
package com.itheima.demo02finalMethod;
public class Zi extends Fu {
@Override
public void show01() {
System.out.println("Zi类重写Fu类的show01方法!");
}
/*
'show02()' cannot override 'show02()' ... overridden method is final
*/
/*public void show02(){
System.out.println("Fu类被fianl修饰的show02方法!");
}*/
}
package com.itheima.demo02finalMethod;
public class Demo01 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show01();//Zi类重写Fu类的show01方法!
zi.show02();//Fu类被fianl修饰的show02方法!
}
}
3.修饰变量
局部变量
package com.itheima.demo03finalvariable;
/*
final修饰的变量:是一个常量,值不能改变
一次赋值,终身不变
*/
public class Demo01 {
public static void main(String[] args) {
/*
定义在方法中的变量:局部变量==>唯一可以使用的修饰符就是fianl
*/
//基本数据类型:值不能改变
final int a = 10;
//a=20;//Cannot assign a value to final variable 'a' 不能给final修饰的变量a赋值
//引用数据类型:地址值不能改变(不能在重新创建对象赋值)
final Student s = new Student("张三",18);
//System.out.println(s);//Student@140e19d
//s = new Student("李四",20);//Cannot assign a value to final variable 's' 不能给final修饰的变量s赋值
//System.out.println(s);//Student@17327b6
//对象中的属性可以改变
s.setName("李四");
s.setAge(20);
System.out.println(s.getName()+"\t"+s.getAge());
}
}
package com.itheima.demo03finalvariable;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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修饰的成员变量(了解):
成员变量:定义在类中方法外的变量
特点:
必须在创建对象前赋值,只能赋值一次
注意:
成员变量的默认初始化值,不能作为fianl修饰的变量的值,必须手动给变量赋值
赋值方式:
1.定义变量的同时,直接赋值
2.在构造方法中给最终变量赋值(构造方法是在创建对象前执行)
3.使用构造代码块赋值(后边讲)
无论使用那种赋值方式,fianl修饰的变量只能赋值一次
*/
public class Person {
//成员变量的默认初始化值,不能作为fianl修饰的变量的值,必须手动给变量赋值
//final int a;//Variable 'a' might not have been initialized
//1.定义变量的同时,直接赋值
final int b = 20;
final int c;
public Person() {
//2.在构造方法中给最终变量赋值(构造方法是在创建对象前执行)
c=30;
//无论使用那种赋值方式,fianl修饰的变量只能赋值一次
//b=200;//Cannot assign a value to final variable 'b'
//c=300;//Variable 'c' might already have been assigned to
}
}
被final修饰的常量名称，一般都有书写规范，所有字母都大写。
4.练习
package com.itheima.demo04Test;
/*
需求:
在商场案例中,所有的工作人员都属于同一个公司,
所以我想要在工作人员类型中定义属性: 所属公司(company)
要求：所属公司一旦定义不允许随意更改！
*/
public class Worker {
public final String company = "传智播客-昌平校区";
public final String address = "北京市昌平区金燕龙办公楼";
public final String web = "www.itheima.com";
}
package com.itheima.demo04Test;
public class Demo01 {
public static void main(String[] args) {
Worker w = new Worker();
System.out.println(w.company);
System.out.println(w.address);
System.out.println(w.web);
//Cannot assign a value to final variable 'web'
//w.web = "www.itcast.cn";
}
}
5.总结
final关键字可以修饰哪些地方？
可以修饰类、方法、变量
final 修饰的特点
修饰类：表明该类是最终类，不能被继承
修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值
二.static关键字
1.static关键字概述(了解)
在实际工作中:
每个人不同的属性定义为非静态的:姓名,年龄,身份证,手机号…
每个人相同的属性定义为静态的:国家(静态==>被共享==>静态区)
2.static关键字的使用(使用)
package com.itheima.demo05static;
/*
定义非静态成员:姓名,年龄
定义静态成员:国家
*/
public class Student {
String name;
int age;
static String country = "中国";
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
package com.itheima.demo05static;
public class Demo01Student {
public static void main(String[] args) {
//创建Student对象
Student s1 = new Student("张三",18);
System.out.println(s1.name);//张三
System.out.println(s1.age);//18
System.out.println(s1.country);//中国
Student s2 = new Student("李四",19);
System.out.println(s2.name);//李四
System.out.println(s2.age);//19
System.out.println(s2.country);//中国
s2.country = "中华人民共和国";
System.out.println(s2.country);//中华人民共和国
//静态成员被所有的对象所共享使用,一个对象修改了静态成员的值,其他的对象在使用就是修改后的
System.out.println(s1.country);//中华人民共和国
}
}
3.static修饰的静态成员的使用方式(重点)
package com.itheima.demo06static;
/*
static修饰的静态成员的使用方式(重点)
定义每个学生私有的属性(非静态):
只有一种使用方式:创建对象使用
定义每个学生共享的属性(静态):
有两种使用方式:
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.demo06static;
public class Demo01 {
public static void main(String[] args) {
//非静态成员只能创建对象使用
Student s = new Student();