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