JAVA 0.00 概念介绍

> 面向对象介绍

#JAVA 官方文档
https://docs.oracle.com/javase/10/docs/api/index.html?overview-summary.html 
***
#JAVA 与 C 区别
* JAVA 没有C的指针操作，会自动检查操作是否越界，有严格的逻辑规范（面向对象）；JAVA 完全采用动态内存分配，并自动管理内存生命周期（自动垃圾回收）；所以相比起C，JAVA 更容易写，更不容易犯错，但是性能绝大多数时候比不过C；而且完成相同的功能，JAVA总是需要更多的内存。
*两个小插曲:*
```
    高手程序员和菜鸟程序员做同一个JAVA项目，代码大体类似；但是做同一个C项目，可能代码就完全不同了。
    这正是因为JAVA 的写法受面向对象的思想限制，所以高手菜鸟的想法都大致相同，也能互相理解。这使得JAVA更加适合大型项目，因为易于合作和交接；参与者可以很多，水平可以层次不齐。
    而如果是一个C写的大项目，可能会需要更密切的沟通以及互相学习，虽然多沟通多学习是正确的，但是成本也就高了。
```
```
    hadoop 是JAVA写的 最著名最成功的产品之一，官方任然建议其压缩功能使用本地库（C语言实现的库），因为JAVA性能比不过C。
```
* JAVA 跨平台，在一台机器上编译好的JAVA 包可以在所有机器上运行，不像C每换一个平台就要重新编译一下。
```
    JAVA的跨平台是建立在JVM虚拟机上的，要事先在每个平台装对应的JVM虚拟机，才能跑JAVA。
```
***
#面向对象概念以及JAVA中的实现
##什么是对象
万物都可以是对象，对象是一个抽象的概念，相当于中文中的“东西”，什么是东西？   
对象都具有状态/变量,行为/方法，标识/名字。
在JAVA中，只有基本类型（比如int）不是对象（为了性能）。
```
class 类名{
    int 变量名 = 1；
    int 方法名() {
        xxx；
    }
}
```
调用方式
```
类名 abc； //仅仅是一个引用
abc = new 类名()；// abc 现在是一个类的标识了
abc.方法名()； // 调用这个类的方法
```
***
##关于构造器
构造器就是构造一个对象的方法，与对象同名，在调用new xxx()的时候自动调用
```
import java.util.*;

public class test{
    public static void main(String[] args){
        //三种不同的构造器
        obj a = new obj();
        obj b = new obj(1);
        String abc = new String("abc");
        obj c = new obj(abc);
    }
}

class obj{
    obj(){ //没有参数的构造器称为默认构造器或者无参构造器
        System.out.println("no arg");
    }
    obj(int a){
        System.out.println("int"+a);
    }
    obj(String a){
        System.out.println("String"+a);
    }
}
```
编译器会给没有构造器的类建一个默认构造器，但是如果你定义了**任何**构造器，编译器就不会给你加自动的默认构造器了。
尽量不要在构造器中调用不是final/private修饰的方法，因为如果构造器使用的方法被子类重写的话，子类构造器就不能正确的调用基类构造器了。
###用this调用构造器（this表示当前类的引用）
```
import java.util.*;

public class test{
    public static void main(String[] args){
        obj a = new obj();
    }
}

class obj{
    obj(){
        this(123);//这样调用构造器必须放在方法的第一行
        System.out.println("no arg");
    }
    obj(int a){
        System.out.println("int"+a);
    }
}
```
***
##对象/变量/方法的修饰符以及其作用
###**static**
####**用static修饰变量和方法** 
static使得某特定方法/变量 只有单一的存储空间，同时我们可以在不创建对象的情况下调用static方法。
JAVA语言的入口public static void main(String[] args) 就是一个static 方法
```
import java.util.*;

public class test{
    public static void main(String[] args){
        obj.print_a();    //static方法可以直接调用
        //obj.print_h();  //这个不可以
        
        obj A = new obj();
        A.a = 2;
        A.b = 20;
        A.print_a();        // =2
        A.print_b();        // =20

obj B = new obj();
        B.print_a();        // =2 
        B.print_b();        // =10
    }
}

class obj{
    static int a = 1;
    int b = 10;
    static void print_a(){
        System.out.println("a="+a);
    }
    void print_b(){
        System.out.println("b="+b);
    }
}
```
***
###访问权限控制
####**public**
所有人都有访问的权利
>如果希望某各类被客户端使用，那么就应该把这个类定义为public
每一个.java文件只能有一个public类，且这个类名称必须与文件名相同
.java文件中可以没有public类

####**protected**
该类的子类可以访问，同时也有包访问权限
####**包访问权限（默认）**
同一个包内的其它代码拥有访问的权利
> JAVA 不允许把私人代码加入到公共包中以防止私人用给一个包加一段代码的方式来访问一些敏感数据。
但是那些不是官方发布的包就没有这个待遇了。
####**private**
只有类的内部成员能访问
***
###**final**
####**用final 修饰基本类型**
表示常量，这个变量只能被赋值一次
####**用final 修饰方法**
子类不能修改这个方法，保持方法在继承的类中行为不变。
####**用final 修饰类**
不能被继承
####**用final 修饰对象**
只能表示一个引用不变，不能表示一个对象不变，但是这样提供了代码的灵活性
```
final obj working_on;
working_on = new obj(xxx);
...
working_on = new obj(xxx);
...
```
***
##继承
* 子类继承父类，同时可以重定义父类中的内容,用extends关键词
* 子类的构建是扩散的方式，先构建父类（也叫基类），然后再构建子类
> 会按继承顺序运行父类和子类的构造器
同时也意味着父类声明为private的成员 子类的方法无法获取，因为父类这时相当于子类中的类中类。

* this代表当前类，super代表父类
* 如果子类构建父类的时候需要构造器函数，必须显式声明，且必须是子类构造器的第一行
* 子类的对象可以向上转型成父类的对象
```
import java.util.*;

public class test{
    public static void main(String[] args){
        obj_son a = new obj_son();
        System.out.println(a.get_num());
        System.out.println(a.get_n());
    }
}

class obj{
    private int num = 0;
    obj(){
        System.out.println("create obj without arg");
    }
    obj(int i){
        System.out.println("create obj with"+i);
    }
    public int get_num(){
        return num;
    }
}

class obj_son extends obj{
    obj_son(){
        super(1);    //调用父类的构造器
        System.out.println("create obj_son");
    }
    public int get_n(){
        //return num； 这样不行，因为num是父类的私有成员
        return super.get_num(); //调用父类的get_num方法
    }
}
```
***
###抽象类
* 用abstract 修饰方法和类，表示这个方法目前没有具体实现，这样的类就是抽象类，不能实例化。
* 抽象类是给子类继承用的，子类自己补上抽象类“抽象”的部分。
```
import java.util.*;

public class test{
    public static void main(String[] args){
        employee p = new employee();
        p.set_id(1);
        System.out.println(p.get_id());
        p.set_name("abc");
        System.out.println(p.get_name());
    }
}
abstract class person{
    int id;
    String name;
    void set_id(int i){
        id = i;
    }
    int get_id(){
        return id;
    }
    abstract void set_name(String n);
    abstract String get_name();
}

class employee extends person{
    void set_name(String n){
        super.name = new String(n);
    }
    String get_name(){
        return super.name;
    }
}
```
***

乱读天书， 不求甚解

乱读天书，不求甚解