java关键字

import java.util.List;

/**
 * 关键字：static ,final,abstract,interface,
 */
/** static 不能修辞类，但可以修辞内部类 */
public/* static */class KeyWords {
 /* ------static---静态的-- 关键字 */

 /* static不能修辞构造方法，构造方法是属于对象的，不属于类 */
 public/* static */KeyWords() {
  this.num = 50;
 }

 // static修辞属性,通过类来访问KeyWords.count;
 private static int count;

 /* KeyWords ks=new KeyWords(); */
 // 实例属性，通过属性来访问，ks.age;
 private int age;

 /* static修辞方法,通过类来访问：KeyWords.methodStatic(); */
 public static void methodStatic() {
  count = 20;
  // 静态方法不能访问非静态属性
  // this.age=30;

 }

 /* 实例方法,通过实例来访问：ks.methodInit(); */
 public void methodInit() {

  count = 40;
  this.age = 60;
 }

 /**
  * static修辞代码程序块，简单的说也是一个静态方法，就是它没有方法名 类加载时执行的代码
  */

 /**
  * 类加载时机： 1.调用静态成员时进行类加载： 例如：static{},static int count;static
  * methodStatic()加载 2.类实例化的时候：KeyWords ks=new KeyWords();加载KeyWords类
  * 3.手动加载时：Class.forName(类名);使用在JDBC编程加载驱动
  */

 /**
  * 一个程序运行的过程： 1.启动JVM 2.类的加载 3.运行main方法
  *
  */

 static {
  System.out.println("static block!");
 }
 /* 实例代码块 */
 {
  System.out.println("Init block!");
 }

 /*------final---最终的--关键字--修辞属性，方法和类*/

 // 常量,值不可变，在构造方法中初始化
 private final int num;

 // 静态常量,直接初始化,用于生成对象的个数
 private static final int num2 = 20;

 public KeyWords(int num) {
  //初始化final常量
  this.num = num;
  //生成对象
  KeyWords[] ks=new KeyWords[num];
 }
 
 /**初始化对象个数
  * KeyWords ks1=new KeyWords(10);
  * KeyWords ks1=new KeyWords(20);
  * */

 /* 修辞方法，不能被子类覆盖 */
 public final void methodFinal() {

 }

 /* 修辞局部变量，修辞形参，值不可变 */
 public void methodFinalPara(final int para) {

 }
 
}
/**final,static 的例子*/

class Person{
 //人的手臂数目
 private final int numberOfHand=2;
 //身份证号码
 private final int ID;
 /*构造方法初始化*/
 public Person(int ID){
  this.ID=ID;
 }
}

/**abstract抽象--关键字--修辞类和方法*/

abstract class KeyWordsOfAbstract{
 
 private String  name;
 
 
 /*构造方法*/
 public KeyWordsOfAbstract(String name) {
  this.name = name;
 }
 
 //修辞方法
 abstract public void move();
 //修辞方法
 abstract public void eat();
 //不是抽象方法
 public void save(){}
 
 /*一个类中有抽象方法，那么这个类必须定义为抽象类
 一个类不包含任何抽象方法，也可以定义为抽象方法*/
 
 /*抽象类和普通类有什么区别？
 抽象类不能实例化，只有通过它的子类来实例化
 abstract和final相对立*/
  
}

/**interface接口--关键字--接口是特殊的抽象类*/

interface KeyWordsOfInterface{
 
 public boolean  save(Object obj);
 
 public boolean delete(Object obj);
 
 public List select(String str);
 /*抽象方法*/
 public boolean update(Object obj);
 //静态常量
 public  int count=20;
 
 
 /**接口和抽象类的区别：
  * 1.所有的方法都是抽象方法
  * 2.所有的属性都是静态常量
  * 3.接口没有构造方法,抽象类有构造方法---本质区别
  * 4.一个类同时可以实现多个接口
  * class ClassName implement interface1,interface2,interface3{
  *
  * }
  *
  * 5.一个接口可以同时继承多个接口
  * class interfaceName extends interface1,interface2,interface3{
  *
  * }
  *
  * 接口把服务的提供者和服务的使用者分离开。形成了软件的面向接口编程
  * ---高内聚，低耦合。
  * */
 
 /**
  *接口是特殊的抽象类，抽象类不能实例化，必须产生子类，就产生了
  *继承关系，继承产生了多态，接口丰富了对象的多态，那也满足多态的两大
  *定理。接口既然丰富对象的多态，那么对象的是从类产生的，类是万物世界的
  *抽象和封装，封装的是数据和行为，一种抽象的数据类型。抽象的数据类型
  *来源于现实世界，也就是把现实世界的万物通过面向对象的思想来描述，再程序
  *化。程序又是计算机运行的，软件又是程序组成的，也是计算机组成的部分。
  *软件是软件开发团队开发的。开发团队也是要通过面向对象的思想和语言来
  *开发的。面向对象的语言有很多，例如：Java，C#,Delphi等。
  *那么Java开发的程序又是通过Java虚拟机来运行的，Java虚拟机是架在Java软件和
  *操作系统之间的，他是怎么运行的Java文件的和管理Java文件的，C和C++是建立
  *在操作系统的平台上。C和C++的程序直接和操作系统的内存进行操作，
  *那java啦？虽然java不能操作内存的地址，但是可以使用内存的地址。
 */
 
 /**
  * java语言是很简单的，那是他提供给我们方便的使用，方便的接口调用，使用对象。
  * 但要学会灵活的使用对象和设计对象的思想去解决现实的问题，那还是要经历
  * 一个过程：接口---抽象类--继承--多态，对象--类--封装--抽象--数据类型
  * --数据--现实世界--对象---软件--语言--程序--计算机--操作系统--内存。
  *
  * */
 
 
}