Java基础笔记

java面向对象： 找对象， 建立对象， 使用对象，  维护对象的关系。

java 设计模式： 针对此类问题最有效的解决方法
  Java23中设计模式：
单例设计模式：解决一个类只在内存中存在一个对象
 如何让一个类在内存中只存在一个对象？
  1. 禁止其他的程序，通过此类类创建对象
 2.既然外部不能通过此类创建对象了，我们要用对象，就可以在本类里面创建对象。
 3.为了其他应用程序能够访问到本类里面创建的对象，我需要对外界提供一种访问方式。
 
 如何用代码体现出来：
 1.私有化构造方法
 2.在本类中创建本类对象
 3.对外界提供访问的方法
class Person{
String name;
private Person(){}//私有化构造方法
static Person p=new Person();
public static Person getInstance(){
 return p;
}
}
public class mingzi{
public static void main(String[] args)
{
 person A=Person.getInstance();
 A.name="xiaoming";
 person B=Person.getInstance();
 System.out.println(B.name);
}
}
A,B在栈中指向的是堆中Person new出来的同一个实例。

java中定义了8种基本类型：boolean char byte short int long float double

Java接口比Java抽象类更抽象化

程序执行过程：程序首先存在于“硬盘”当中，当点击执行他的时候，首先从硬盘装在到内存当中，
 1.Load（装载）到“内存”
 2.代码在“内存”中，“操作系统代码”发现程序代码，从代码中的main方法开始执行。
 3.执行过程中的内存管理：
   heap（堆）：存放new出来的东西。
   stack（栈）：存放局部变量
   data segment（数据部分）：存放静态变量、字符串常量
   code segment（代码部分）：存放代码

继承：
extends
1.提高代码的复用性，简化代码。
2.让类与类之间产生了继承关系，才有了后面的多态特性的存在。
注意：千万不要为了获取其他类的功能，简化代码，而建立继承关系。

3.子类拥有父类的成员，子类不能拥有父类中被private修饰后的成员
4.Java多继承 在多层继承中最下层的子类拥有整个继承体系的成员，最上乘的父类里面定义所有子类的共性描述
5.Java中不支持多继承，因为存在安全隐患，当多个父类定义相同的成员，子类对象不确定运行哪一个。
6.Java用多实现来保留多继承的机制（接口）

子父类成员特点：
成员：
1.成员变量
2.函数
3.构造函数

变量： this 代表当前对象的引用 this.变量 首先在本类中找所需要的这个变量，如果没有找到再去父类中找。
 super 用于访问当前对象的父类成员， super.变量
直接父类中找所需变量。
函数： 当子类中出现父类中一样的函数时，当子类对象调用该函数，运行的是子类中的函数，如同父类中的 函数被覆写了一样，这种平旷就是函数的另一种特性：重写（覆盖）。

注意：
1.子类覆盖父类时，必须要保证子类权限大于等于父类，才可以覆盖，否则 编译出错。访问权限修饰符：public>default>private 默认值为default。
2.静态的函数只能覆盖静态的
3.重载：只看同名的方法的参数列表
  重写：子类福来方法要一模一样

有了父类之后构造函数的特点：
在对子类对象进行初始化的时候，父类的构造方法也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super();
调用父类的构造方法要在子类构造方法的第一行。

java多态： 可以理解为事物存在的多种体现形态
例子：动物-猫、狗、猪   人-男人、女人

1.多态的体现
 父类引用指向子类对象
2.多态的前提
 （1）必须得类与类之间存在关系，可以是继承关系，也可以是实现关系
 （2）必须得有重写（否则多态没有意义）
3.多态的好处
 大大提高程序的可扩展性
4.多态的弊端
 提高的程序可扩展性，只能用父类的引用，访问到父类中的成员
多态成员变量的特点：
1.编译期间：参阅的是引用型变量所属的类中是否有调用的方法
2.运行期间：参阅对象所属的类中是否有调用的方法

抽象类：
1.抽象方法一定要在抽象类中
2.抽象类和抽象方法必须要被 abstract 关键字修饰 abstract 只能修饰类和函数
3.抽象的类是不能被创建对象，因为调用抽象的方法没意义
4.抽象类中方法要被使用，必须由子类重写抽象类中的方法，然后创建子类对象来调用
5.抽象类中可以定义非抽象的方法，有事我们需要此类不能被new关键字创建对象时，可以用abstract将此类变成抽象类。
6.子类如果只重写一部分的抽象方法，那么盖子类还是一个抽象类，过抽象类的方法要被使用，子类必须重写抽象类中的所有方法。
值得注意：抽象类和普通类没有太大区别。
 1.抽象类无法通过new关键字创建对象
 2.抽象类里面可以有抽象的方法

java对象的转型：
1.对象的向上转型 ：子类转成父类，默认进行。（父类引用指向子类对象）例子：Animal a=new Cat();(a这个实例只能访问Animal中有的方法或者参数，不能访问Cat中的，相当于以动物的角度去看猫中的动物的通性)
2.对象的向下转型： 父类转成子类，强制进行。例子：Animal a=new Cat(); Cat c=(Cat)a;
关键字：instanceof测试左边的对象是否是右边类的实例。（例子：a instanceof Dog）如果是返回true，如果不是返回false。

java接口： 初步理解，接口是一个特殊的抽象类，当抽象类中全部是抽象方法时，可以通过接口的形式来体现。
class用于定义类
interface用于定义接口

接口中成员的格式：
1.public static final String NAME="小李";//全局常量
2.public abstract void show();//抽象方法

注意：
1.接口中只能出现public访问修饰符
2.接口不可以创建对象，因为里面有抽象方法，需要被子类实现，子类对接口中的所有抽象方法实现后，子类才能够实例化，否则子类就是一个抽象类。
 
java不支持多继承，因为存在安全隐患，当父类中定义了相同功能，功能内容不同时，子类不确定要运行哪一个。
但是java保留了这种机制，并用另一种体现形式来完成表示>>多实现
关系：
 类与类之间：继承关系
 接口与类之间：实现关系
 接口与接口之间：继承关系

接口：提高了我们功能的扩展性。因为它降低食物与食物之间的耦合性（关系紧密程度）

父类 中定义的是多个类中共性的基本功能
接口 中定义的是扩展功能

接口好处：可以多实现，也就是一个类可以实现多个接口

java中的“ 成员变量 ”是声明在类里面的，“ 局部变量 ”是声明在类中的执行的方法里的。
 成员变量 不初始化，系统自动初始化：
 int：0；
 short：0；
 byte：0；
 long：0L；
 char：'\u0000';
 float:0.0F;
 double:0.0D;
 boolean:false;
 所有引用类型：null；

static关键字
作用：是一个修饰符，用于修饰成员（成员变量，成员方法）
1.被static修饰后的成员变量只有一份
2.当成员static修饰后，多了一种访问方式，除了可以对象调用之外，还可以被类直接调用（类名.静态成员）
static特点：
 1.随着类的加载而被加载
 2.优先于对象的存在
 3.被所有的对象所共享
 4.可以直接被类名所调用
 存放位置：静态变量随着类的加载而存在data内存区
    实例变量随着对象的建立而存在于堆内存。

return 作用1：返回方法指定类型的值（这个值总是确定的）
      作用2：结束方法的执行（仅仅一个return语句）

方法的重载 只是与参数的个数、参数的类型有关，跟返回值无关，所以返回值可以不相同。

构造方法： 与普通方法相比，没有返回值。 作用是：给调用类定义的“成员变量”进行初始化。 注！：空构造方法要写上，否则new对象时没有赋值的话会报错！

对象初始化的过程：（堆（heap）、栈（stack）、数据部分（data segment））
1.因为new Student()用到了Student类，所以会把它从硬盘上加载进入内存
2.如果有static静态代码块就会随着类的加载而执行
3.在堆中开辟空间，分配内存地址
4.在堆中建立对象特有属性，并同时对特有属性进行默认初始化
5.对属性进行显示初始化
6.执行构造代码块。对所有对象进行初始化
7.习性对应的构造函数，对对象进行初始化
8.将内存地址给S（给栈中的变量）

包（package）
什么是包？可以理解为文件夹
包的作用：
 1.对类进行分类管理
 2.给类提供了多层命名空间
注意：
 1.类名的全称是 包名.类名
 2.定义包的语句一定要在代买的第一行
javac -d .名字.java（在当前目录编译 名字.java ）
javac -d E.\java 名字.java （在E.\java的目录下编译）

包和包之间用“.”来隔开：package a.b;
为了使包名唯一，通常使用url做包名

访问权限：
public protected  default  private
同一类   ok    ok      ok       ok
同一包    ok    ok      ok
子类   ok    ok      
不同包   ok
类只能被public或者default修饰
当一个记事本中定义了多个类，只能出现一个public类
类中的成员可以被以上4中修饰符修饰

java中的压缩包 ：jar压缩包
jar cvf 压缩包名字.jar 包名1 包名2……

文档注释：
/**
（对此类的功能进行描述）
@author ··（作者名字）
@version··（版本号）
*/
/**
（对方法的功能进行描述）
@param 变量名 说明（传入参数说明）
@return 返回一个··值（对返回值的描述）
*/
注释后，运用jdk中的javadoc工具来进行文档注释的提取。
运用格式为：
 javadoc -d Mydoc（在目录下的Mydoc文件夹中生成文档，如果目录下没有此文件夹，就自动生成一个） -author（提取作者） -version（提取版本号） ArrayOperate.java（类文件的名字）

键盘输入时import（导入）java.util.Scanner包
 Scanner in=new Scanner(System.in);
 in.nextInt();//输入整型
 in.nextDouble()//双精度输入
 in.next()//字符串输入

随机数 import java.util.Random;//导包
Random xx=new Random();//new一个Random对象
xx.nextInt(10);//0~9的随机数
方法二：
 支持多线程！
 Math.random()*10;//0~9的double随机数
 (int)Math.random()*10;//强制转换成0~9int 随机数

排序查询：使用import java.util.Arrays;
 在java.util.Arrays的包中有很多对数组操作  的方法。
 Arrays中的sort();//用来数组升序 排列。

比较：例如 name="时刻"; name.equals("时刻") //用name的值
 和括号中的内容进行比较。成立则返回1。