JavaSE-关键字

关键字的概述和使用

• 关键字就是被java语言赋予特殊含义的单词
• 关键字的特点：组成关键的字母都是小写
• 关键字的注意事项
  (1): goto和const是java语言的保留字
  (2): 类似与editplus这样的高级文本编辑器对关键字都是有颜色变化的

Java—关键字

类型	关键字
与数据类型相关的关键字	boolean、int、long、short、byte、float、double、char、class、interface
与流程控制相关的关键字	if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally
与修饰符相关的关键字	public、protected、private、final、void、static、strictfp、abstract、transient、synchronized、volatile、native
与动作相关的关键字	package、import、throws、extends、implements、this、super、instanceof、new
其他关键字	true、false、goto、const

private

A.关键字的特点

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被其修饰的成员只能在本类中访问
  B.案例演示
  C.最常见的应用
• 把成员变量用private修饰
• 提供对应的getXxx（）和setXxx（）方法
  D.案例演示

现有一个未封装的Person类

public class person
{
String age;//成员变量name
}

修改age

public static void main (String[] args)
{
Persons Q=new Person();
Q.age=-100;
}

封装后

public class Person
{private int age;//成员变量name前面加上private
public void setAge(int num)
{
age=num;
}
public int getAge()
{
return age;
}
}

修改age和打印age后

public static void main (String [] args)

Person Q =new Person();
Q.setAge(20);
System.out.println(Q.getAge());

this
A.关键字的特点
是当前类的对象的引用（简单来说，它就代表当前类的一个对象，谁调用这个方法，那么该方法的内部的this就代表谁）
B.为什么要有this
当我们的局部变量和成员变量相同的时候，如果我们不使用this关键字的话，那么就会导致一个问题：就是局部变量隐藏了成员变量的问题
C.this的应用场景
解决局部变量隐藏成员变量
D.案例演示
this的应用场景

通过this关键字可以明确的访问一个类的成员变量，解决与局部变量名称冲突问题

public class student{
 String name;//成员变量
 int age;//成员变量
 long phone;//成员变量
 String address;//成员变量
 //有参构造方法
 public Student (String name,int age,long phone,String address){
this.name=name;
this.age=age;
this.phone=phone;
this.address=address;
}
//获取成员变量name的值
public String getName(){
    return this.name;//访问的是成员变量name
}
}

通过this调用成员方法

public class Student {

    public void A(){
        System.out.println("A方法执行了......");
    }
    
    public void B(){
        this.A();//调用A()方法
    }
}

super

子类局部范围访问父类成员变量
A.三种使用方法

• super.变量/对象名
• super.方法名（）
• super()

this和super的区别和应用

• 区别：this 代表的是本类对象的引用
  super 代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)

• this和super的使用
  a:调用成员变量
  this.成员变量 调用本类的成员变量
  super.成员变量 调用父类的成员变量
  b:调用构造方法
  this(…) 调用本类的构造方法
  super(…) 调用父类的构造方法
  c:调用成员方法
  this.成员方法 调用本类的成员方法
  super.成员方法 调用父类的成员方法

static

A.画图演示：带有static的内存图

B.static关键字的特点

• 随着类的加载而加载

• 优先于对象存在

• 被类的所有对象共存
  举例：咱们班级的学生应该共用一个班级编号（如果某个成员变量是被所有对象共存的，那么它就定义为静态的）
  举例： 饮水机（用静态修饰）
  水杯（不能用静态修饰）

• 可以通过类名调用
  其实它本身也可以通过对象名调用
  推荐使用类名调用
  静态修饰的内容一般我们称其为：与类相关的，类成员
  C.案例演示（static关键字的特点）

class Person{
   String name;   //成员变量，实例变量
   static String country="china";   //静态变量   类变量
    public void show()
     {
     System.out.println(country+":"+name);
     }
}

D.static的注意事项

• 在静态方法中是没有this关键字的（静态是随着类的加载而加载，this是随着对象的创建而存在的；静态比对象先存在）

• 静态方法只能访问静态成员变量和静态的成员方法 （静态方法只能访问静态，非静态的可以访问静态的也可以访问非静态的）

final

A.final概述：final关键字是最终的意思，可以修饰类、变量、成员方法
B.final修饰特点

• 修饰类: 被修饰类不能被继承
• 修饰方法: 被修饰的方法不能被重写
• 修饰变量: 被修饰的变量不能被重新赋值,因为这个量其实是一个常量
  C.为什么会有final?
  由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final
  案例演示：（final修饰特点）
  a.修饰类

final class Animal{
   public Animal(){}
}
class Cat extends Animal{
}

b.修饰方法

class Animal{
    /**
     * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的.
     * 属于子类本身的方法，编译正常.
     */
    private final void getName() {}

    /**
     *  因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错.
     */
//  public final void getName() {}
}

class Cat extends Animal {
    public static void main(String[] args) {

    }

    public void getName() {}
}
}

c.修饰变量

class Animal{
   private  final  int count=0;
   public Animal(){
   count=1;//报错
   final Object  object=new  Object();
   object =new Object();//报错
}
}

面向对象（final关键字修饰局部变量）

基本类型，是值不能被改变
引用类型，是地址值不能被改变

abstract

抽象类和抽象类方法必须要用abstrct关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();

interface

接口用关键字interface表示 格式: interface 接口名 {}

implements

类实现接口用implements表示 格式: class 类名 implements 接口名 {}

extends

继承
A.通过关键字extends继承一个已有的类，被继承的类称为父类（超类 、基类），新的类称为子类（派生类）
B.Java中不允许多继承，只支持单继承
C.一个子类只能有一个父类，一个父类可以派生出多个子类
D.从父类继承的（private）私有的东西是没有访问权限的，只有拥有权，覆盖不了
案例演示

public class Person {
        //私有方法-只能内部使用，外面无访问权限
       private void age(){
        System.out.println("Psrson age");
     }
       public void say(){
   System.out.println("Person say");
 }
        public void cry(){
        System.out.println("Person cry");
     }
       public void run(){
  System.out.println("Person run");
 }
}
 
 
public class ExPerson extends Person {
 
 //覆盖父类方法
 public void say(){
  System.out.println("Son say");
 }
        //重载
    public String cry(String cry){
        System.out.println("Son cry");
        return cry;
    }
      //增加父类所没有的方法
 public void sleep(){
              //用super关键字访问父类方法
        super.say();
             System.out.println("Son sleep");
 }
 
 public static void main(String[] args) {  
        // TODO Auto-generated method stub  
  Person per = new Person();  
  ExPerson exper = new ExPerson();  
        
       per.say();
        exper.say();//覆盖后的方法
        exper.sleep();//增加的方法
        exper.cry("cry");//重载后的方法
        exper.cry（）；//继承父类的方法
 }

子类可以继承父类的属性和方法，但是子类还可以拥有自己独有的属性和方法，当然，子类还可以重写父类的方法。在调用的时候，首先要学会调用子类的方法，然后在调用父类的方法，如果重写父类的方法，那么子类的方法就可以覆盖了父类相同的方法

面向对象（标准的学生类代码及其测试）

案例演示：把手机类的成员private修饰，给出getXxx()/setXxx()方法

class Demo04_Student{
    public static void main(String[] args){
        Student stu1 = new Student();      //使用空参构造
        stu1.setName("张三");               //设置姓名
        stu1.setAge(23);                    //设置年龄
        //getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作（赋值）
        System.out.println("我的姓名是:" + stu1.getName() + "..." + "我的年龄是:" + stu1.getAge());
        Student stu2 = new Student("李四", 24);
        stu2.show();                        //show方法只是为了显示属性值(打印).
        stu2.setName("王五");
        stu2.show();
    }
}

class Student{
    private String name;
    private int age;

    public Student(){

    }

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return this.age;
    } 

    public void show(){
    System.out.println("我的姓名是："+name+"..."+"我的年龄是："+age);
    }
    }