【咸鱼期末】Java知识点（1）

一. 基础知识

1. JavaSE Java Platform Standard Edition 标准版本
   JavaEE Java Platform Enterprise Edition 企业版本
   JavaME Java Platform Micro Edition 微机版本
2. java的编译处理运行过程
   .java文件 源文件
   -> javac HelloWorld.java
   .class 文件 字节码程序
   -> java HelloWorld
   运行结果
3. 基本数据类型占用空间

4. 引用类型

• 在 Java 中，对象、数组都是引用类型。
• 引用类型指向一个对象，指向对象的变量是引用变量,非常类似于 C/C++ 的指针。
• 所有引用类型的默认值都是 null 。
• 引用类型变量在声明后必须通过 实例化 开辟数据空间，才能对变量所指向的对象进行访问。

5. Java 使用 final 关键字来修饰常量
   如：final double PI = 3.1415926;
6. 数据类型转换优先级
   byte——> short, char ——> int ——> long ——> float ——> double

  //强制类型转换
  int i1 = 123;
  byte b = (byte)i1;

另：定义 float 类型时必须在数字后面跟上 F 或者 f
使用 long 类型时必须在数字后面跟上 L

7. 当使用“与”逻辑运算符时，当得到第一个操作为
   false 时，其结果就必定是 false ，这时候就不会再判断第二个操作了。

二.封装

1. private: 只能被该类的对象访问。
   default: 即不加任何访问修饰符，只允许在同一个包中进行访问。
   protected: 只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。在同一个包中也可以访问。
   public: 不仅可以跨类访问，而且允许跨包（ package ）访问。
   此外，不能用protected和private修饰类。

三.继承

1. 所有的类的共同的祖先都是 java.lang.Object
2. 子类继承了父类中所有非 private 成员方法（除了构造方法 和 所有 非 private 的成员变量）。
3. 构造函数只能够被调用，不能被继承。
4. super 必须作为构造方法的第一条执行语句 。
5. 重写：子类覆盖父类继承来的方法（必须同名且同返回类型且同参数列表）： override
   重载：自身的某个方法改变参数列表 （参数个数 或 类型 或 顺序）。被重载的方法 可以改变返回类型，可以改变访问修饰符。
6. final关键字 可以修饰不能被继承的类，也可以修饰不能被子类改写的方法

四.抽象类

1. 抽象类不能被实例化
2. 抽象方法的具体实现由它的子类确定，在父类中声明该方法为抽象方法
   抽象方法只包含一个方法名，没有方法体，后面直接跟一个分号，而不是花括号。

public abstract class Form
   …
  public abstract void draw();
}

3. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
4. 抽象类可以拥有构造方法，只是不能直接通过构造方法构造实例而已。

五.抽象变量与方法

1. 静态变量在程序初始化时被创建，可被该类 所有的 实例使用和修改。

六.接口

1. 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，除非声明为抽象类。

public interface GroupedInterface extends Interface1, Interface2, Interface3 {
	// constant declarations
	double E = 2.718282;	//默认公开 静态 终态
	// method signatures
	void doSomething( int i , double x); //默认公开 抽象
	int doSomethingElse(String s);
}

public class SomeClass implements GroupedInterface {
		…
		// method definitions
	void doSomething(int i , double x){
		…
	}
	int doSomethingElse(String s)
		…
	}
}

2. 接口中可以含有变量，变量会被隐式的指定为 public static final ，显式修饰符里只允许拥有上述三个的任意一个或多个，不能违背（用 private 修饰会报编译错误）,
3. 接口中的方法会被隐式的指定为 public abstract，显式修饰符里只允许拥有上述两个的任意一个或多个，不能违背
4. 接口和抽象类的区别：
   接口没有构造方法，抽象类可以拥有。
   接口中所有的方法必须是抽象方法 public abstract，抽象类不一定。
   接口只能包含public static final 成员变量，抽象类中变量类型可以自己定义。
   接口不是被类继承了，而是要被类实现。类对于接口用impletements，类对于类用extends。接口对于接口用extends，类对于类用extends。
   接口支持多继承，抽象类不支持。
5. 接口可以作为类型使用
   把实现了接口的类实例赋给接口变量

 public interface Foodable{}
 public class Fish implements Foodable {}
 Foodable food = new Fish();
 //接口变量可以调用被类实现的接口的方法

6. Java8新特性（1）
   接口中可以放入方法的实现，避免修改实现该接口的类的代码。

public interface DoIt {

	void doSomething (int i , double x);
	int doSomethingElse (String s);
	default boolean didItWork (int i , double x, String s) {
		return true;
	}//这里必须是default，其他诸如public都不行
}

这样实现类就无须（不是不能）实现接口中已经被定义的代码

class A implements DoIt{

	public void doSomething(int i, double x) {
		// TODO 自动生成的方法存根
	}
	public int doSomethingElse(String s) {
		// TODO 自动生成的方法存根
		return 0;
	}
}

7. Java新特性（2）
   接口中也可以放入静态方法的实现

public interface DoIt {
	void doSomething (int i , double x);
	int doSomethingElse (String s);
	static int toolfunc int x) {
		// Method body
    }
}

七.多态

1. 多态的定义：在代码中为同一名称的方法（接口）提供不同的实现
2. 编译时多态：方法的重载（overload)

 public double createRect (Point p1, Point p2){}
 
 public double createRect (double x1, double y1, double x2, double y2){}

运行时多态：程序中定义的引用变量引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

public class A {
 public String show(A obj){
	return ("A and A");
  }
}

public class B extends A{
 public String show(A obj){
	return ("B and A");
  }
}

3. 二者区别的个人理解：编译时是同一个类里，改变方法的参数列表，使方法产生差异性；运行时是不同类之间的相互比较通过不同类之间方法的重写，来产生差异性。
   

八.专题

1. 一维数组

 // 1st way
int[] nums1 = new int [10]
// 2nd way
double[] nums2 = {0.0, 0.0, 0.0};

2. 二维数组

int[][] arr = new int [2][3];
int[][] mat = {{0,1,2}, {1,2,3}};

for(int i=0; i<mat.length; i++)
  for(int j=0; j<mat[i].length; i++)
	  System.out.println(mat[i][j]);
  }
}

3. 方法的重载 overload
   ----同名不同参，可在同一个类中出现
   方法的重写 override
   ----同名又同参，又同返回值（一模一样），子类与父类中出现
4. return; 只能在返回值为void的函数中调用
5. 一个文件里只能有一个public类，此文件名必须和public类名相同
6. 类里只能定义属性（成员变量）和方法（成员方法和静态方法）