1. static：
很多时候将static直接翻译为静态，但是这个描述不够准确，static是用来定义类变量，也就是说被static定义的变量不属于这个类的某个实例。所以被static定义的成为类变量、类方法；反之为实例变量
需要注意的是，在静态方法中不能直接通过对象去调用，需要通过类去调用
123456789101112131415 public class NewClassTest {
public void jump(){
System.out.println("This is NewClassTest");
}
public void run(){
System.out.println("This is run");
jump();
}
//static
public static void sFun(){
new NewClassTest().run(); //correct
run(); //error
}
}
2. 类在内存中，每一个类在创建在栈内存中，当创建一个对象的时候，将非类变量再堆内存中创建，而类变量是不会因为创建对象而在堆中重新创建
并且访问类变量不能用对象的方式，必须用类的方式！
3. 对象、引用和指针：
Java中的变量都是引用，指针被封装了。当对象没有被引用时候就会被垃圾回收机制回收。也可以将对象赋值null，标记回收此对象。
4. 类名和文件名的关系
5. Java的set和get方法
5. 包的概念：
包的命名：
父## 包和子包之间的类关系：
import包：
特殊情况的引用
Java文件结构
6.构造器
Java可以自定义构造，可以简单理解为C++的构造，如果定义了私有的构造，即不使用默认的无参构造，那么在创建对象的时候，默认的构造是非法的，如果需要多个构造，那么需要定义多个构造，形成构造的重载：
package aaa;
public class Study {
private int num;
private String name;
//这里既可以为public也可以为private，具体区别待理解
private Study(String name){
this.name = name;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Study s = new Study("aaa"); //这里合法！
Study ss = new Study(); //这里会报错！
System.out.print(s.name);
}
}
关于构造在的初始化过程：
在构造中调用构造：
package aaa;
public class Study {
private int num;
private String name;
//无参构造
public Study(){};
//一个参数的构造
private Study(String name){
this.name = name;
}
//两个参数的构造
public Study(String name, int num){
this(name); //调用了一个参数的构造，用this
this.num = num;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Study s = new Study("aaa"); //没有被其他构造再调用，只初始化自己，num默认初始化为0
System.out.println(s.name);
System.out.println(s.num);
Study ss = new Study("bbb", 2); //在构造中调用了一个参数的构造
System.out.println(ss.name);
System.out.println(ss.num);
}
}
7.继承
注意：Java是单继承，不同于C++，每个子类只有一个直接父类。关键字extends
修饰符 class SubClass extends SuperClass{
//类定义部分
}
子类继承后获得父类的全部变量和方法，构造除外。
**但是可以间接继承多个父类**
方法的覆盖（Override）:
super关键字
子类需要调用父类中被覆盖的实例方法，可以用Super关键字来调用，需要注意的是和this不能出现在static关键字修饰的方法中一样，super也不可以调用类方法
//在两个文件中定义类
//父类
public class Bird{
public int num = 1;
public void fly(){
System.out.println("Bird can fly!");
}
}
//子类
public class Drck extends Bird{
public int num = 2;
public void fly(){
System.out.println("Drck can not fly!");
}
public void accessBirdNum(){
System.out.println(super.num); //调用父类变量
}
public void accessDrckNum(){
System.out.println(num);
}
}
需要注意的是有隐藏的情况，在父类和子类同名的情况下：
//父类
public class Bird{
public String fly = "Bird can fly";
}
//子类
public class Drck extends Bird{
//实际上父类的fly被这里隐藏了
private String fly = "Drck can not fly";
}
//打印
public class Study {
public static void main(String[] args) {
// TODO Auto-generated method stub
Drck dc = new Drck();
System.out.println(dc.fly); //这里编译不过，
System.out.println(((Bird)dc).fly); //向上转为父类
}
}
8.多态
//父类
public class Bird{
public String name = "Bird";
//父类独有的方法
public void birdTest(){
System.out.println("Bird fly");
}
//会被子类方法覆盖
public void test(){
System.out.println("父类的test");
}
}
//子类
public class Drck extends Bird{
public String name = "Drck";
//子类独有的方法
public void drckTest(){
System.out.println("drck fly");
}
//覆盖了子类
public void test(){
System.out.println("子类的test");
}
}
public class Study {
public static void main(String[] args) {
// TODO Auto-generated method stub
Bird bd = new Drck();
System.out.println(bd);
bd.birdTest(); //父类的方法
bd.test(); //子类的方法
//bd.drckTest(); //编译的类型是Bird，没有drckTest方法，编译报错
}
}
引用变量的强转
强转的规则：
1. 基本的数值类型
2. 有继承关系的两个类型之间
是否可以强制转换可以用instanceof来判断
子类和父类的封装
使用继承的前提：
9.类的初始化
10.Java增强的包装类
•自动装箱（AutoBoxing）和自动拆箱(AutoUnboxing)
Java中除了基本数据类型外，所有引用类型的变量都继承自Object，都可当做Object类型变量使用。基本数据类型在Java中通过特定的包装类实现：
public class Study {
public static void main(String[] args) {
Integer inObj = 2;
Float flObj = 2f;
Double dbObj = 2.0;
Byte byObj = 1;
Character chObj = 'c';
Boolean bObj = false;
Short shObj = 1;
//Object
Object ob = true;
if (ob instanceof Boolean) {
bObj = (Boolean)ob;
}
}
}
自动装箱和拆箱的过程由Java完成，利用了向上转型的特性。不需要我们认为干预，但是要注意的是不能将错误的类型装箱和拆箱：将int和Float混用
String和其他类型的互转
### 基本类型转String用praseXXX(String s)或者构造XXX(String s)
### String转基本类型用s.valueOf()方法或者 + ""的方式
``Java
public class Study {
public static void main(String[] args) {
int num = 2;
float numf = 2.2f;
String snum = "123";
//String转换为基本类型，使用praseXXX(String s)
int num1 = Integer.parseInt(snum);
System.out.println("int num:" + num1);
//String转换为基本类型，使用构造XXX(String s)
float num2 = new Float(numf);
System.out.println("float num:" + num2);
//基本类型转换为String,使用String的方法s.valueOf()
String s = String.valueOf(numf);
System.out.println("String num:" + s);
//基本类型转换为String,使用+符号
String s1 = num + "";
System.out.println("String plus num:" + s1);
}//main
}
## toString方法
```Java
package aaa;
//定义个类，并重写toString方法
public class Bird{
private int wing;
private int eye;
//无参构造
public Bird(){
}
//有参构造
public Bird(int wing, int eye){
this.wing = wing;
this.eye = eye;
}
//省略getter和setter方法
//Override toString
public String toString(){
return "一只鸟有" + wing + "双翅膀" + eye + "双眼睛";
}
}
//调用
public class Study {
public static void main(String[] args) {
Bird bd = new Bird(2,2);
System.out.print(bd);
}//main
}
equals方法
单例类
public class Singleton {
private static Singleton instance;
//将默认构造私有，方式重复创建对象
private Singleton(){
}
//通过开放的方法获取唯一的实例
public static Singleton getInstance(){
if (null != instance){
instance = new Singleton();
}
return instance;
}
}