Java 源程序与编译型运行区别
我们写的.java代码，就是一个文本记录文件，需要编译后转换为.class文件。之后才能被虚拟机所识别，并解释运行。
注，这里不同于exe可以直接在windows操作系统上执行，java在更高一层解释器上执行，因为在不同的造作系统上都有单独的java解释器,所以java也具有跨平台的特性，对程序编写者来说不用操心那么多、
Java主要特性
* 1）Java语言特点和C++接近。Java摒弃了C++中晦涩难用的特性，比如运算符重载，多继承，自动的强制类型转换。尤其是，Java不用指针。
* 而是引用，提供自动回收，是程序原不必为内存管理而担忧。
* 2）面向对象，java程序可以认为是一系列 类和对象 的集合，而这些对象通过调用彼此的方法来协同工作public class HelloWorld {
public static void main(String[] args){
System.out.println("Hello World");
}
}类和对象
了解普通成员变量和类变量，也加静态变量，全局变量（内存的方面去理解）
static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
public class Dog {
// 类变量，类变量也声明在类中，方法体之外，但必须声明为static类型。是类的全局变量，共享, 不能被类对象直接访问
// 。
static int change;
// 成员变量，成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化；
// 每个对象成员都独立拥有内存空间，只能通过类对象来访问
String breed;
int age;
String color;
void barking(){
System.out.println("this is barking function!");
}
void hungry(){
System.out.println("this is hungry function!");
}
void sleep(){
System.out.println("sleep ...");
}
void changeValue(int value){
change = value;
System.out.println(change);
}
void showValue(){
System.out.println(change);
}
public static void main(String[] args){
Dog obj_dog = new Dog(); //调用类的构造函数生成对象，虽然这个类没有显示的写出构造函数
obj_dog.hungry();
obj_dog.changeValue(12);
Dog obj_dog2 = new Dog();
obj_dog2.changeValue(32);
Dog obj_dog3 = new Dog();
obj_dog2.showValue();
obj_dog.showValue();
obj_dog3.showValue();
Puppy obj_puppy = new Puppy("小白", 12, "哈士奇");
}
}
class Puppy{
/*构造方法，在生成类对象的时候调用，可输入参数, 所有类都有构造方法。与类同名*/
Puppy(String name, int age, String breed){
System.out.println(name);
}
}运行结果：
this is hungry function!
12
32
32
32
32
小白访问控制
四类访问控制
修饰类
默认访问权限（包访问权限）：用来修饰类的话，表示该类只对同一个包中的其他类可见。
public：用来修饰类的话，表示该类对其他所有的类都可见。
修饰类的方法和变量
默认访问权限（包访问权限）：如果一个类的方法或变量被包访问权限修饰，也就意味着只能在同一个包中的其他类中显示地调用该类的方法或者变量，在不同包中的类中不能显示地调用该类的方法或变量。
private：如果一个类的方法或者变量被private修饰，那么这个类的方法或者变量只能在该类本身中被访问，在类外以及其他类中都不能显示地进行访问。
protected：如果一个类的方法或者变量被protected修饰，对于同一个包的类，这个类的方法或变量是可以被访问的。对于不同包的类，只有继承于该类的类才可以访问到该类的方法或者变量。
public：被public修饰的方法或者变量，在任何地方都是可见的。
Java数组
注意创建数组的方式, 和普通变量不同，数组需要制定大小；因此需要使用 new int[size]方法，
int[] array = new int[3]
/*
* Test code
*
*
* idea 存在很多快捷方式
* 输入psvm 为主函数
* soupt 输出等
*
* */
public class Test {
void array_fun() {
/*数组是用来存贮 固定大小 的 同类型 元素*/
/*创建数组方式： dataType[] arrayRefVar，
穿件数组时候需要指定大小;
*/
// 创建数组方式1， dataType[arraySize]创建一个数组,然后填充值，相当于先找连续内存空位，然后陆续填充值
int[] array = new int[3]; // 创建数组，需要指定大小，使用int[3]创建了一个数组，新创建的数组的引用赋值给变量 array。
array[0] = 1;
array[1] = 2;
array[2] = 3; //给数组填充值
// 创建数组方式2 {}方式，直接给出所有值完成填充，相当于来一批值，直接给你找连续空位，填上去，
int[] array2 = {1, 2, 3};
int[] array3 = new int[]{1, 2, 3};
//循环输出
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
for (int i : array3)
System.out.println(i);
}
public static void main(String[] args) {
StringBuffer ss = new StringBuffer("上海自来水来自海上 ");
ss.append("山西运煤车煤运西山 ");
ss.reverse();
System.out.println(ss);
Test obj = new Test();
obj.array_fun();
}
}
// STOPSHIP: 2020/4/1Java多态
/*
* java多态
*
* Java多态就是同一个接口，使用不同的实例而执行不同的操作；
* Parent p = new Child();
*
* 多态的优点：
* 1）消除类型之间的耦合关系；
* 2）可替换性，更加灵活简便；
*
* 多态存在的三个必要条件：
* 1）继承
* 2）重写
* 3）父类引用指向子类对象
*
* ----------------------------------------------------------------------------------------------
* 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
* 多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
*
* */
//package pock;
public class Polymorphic {
void fun() {
System.out.println("this is Father class 's fun");
}
}
class Child_of_Polymorphic extends Polymorphic {
void fun() {
System.out.println("this is child 's fun");
}
}
class run {
public static void main(String[] args) {
Polymorphic p = new Child_of_Polymorphic();
p.fun();
Polymorphic p2 = new Polymorphic();
p2.fun();
}
}
