JAVA基础心得

    java  基础：

一、java 随笔录：

   1. 浮点数与整数相比较  只要值相等 就相等 不需要考虑后面的.000、

   2. 例子：

   int num1 = 5,num2 = 10;
   System.out.println( ""+num1+num2);//前面有双引号 代表的是字符串的拼接
   答案是 510 这是相当于 字符串的拼接

3.  &&短路运算符：

 前面是假  直接否定后面的 不进行运算 
在冒泡排序当中 一定记住 第二个循环中需要，总的数目减去上一层的循环数，
  并且（减一)否则会出现数组越界的问题.

二、 java 数组的总结：

1. 数组是引用数据类型
2. 创建数组是，会开辟连续的内存空间
3. 数组长度使用length属性获取
4. 数组元素的下标从0开始 
5. 数组下标越界问题

三、方法：

    所谓方法就是用来解决一类问题的代码的有序组合，是一个功能模块（方法就是功能）
   方法声明：
  语法格式：
访问修饰符 返回类型 方法名（参数列表）{
    }  
    
    public static void main(String[] args){
    System.out.println("hello world")
    }
  方法分类：  // 方法不能被嵌套定义
根据方法是否带参数、是否返回值，可分为四类：
      有返回值的方法  必须要有return 语句。
1. 无参无返回值方法
2. 无参带返回值方法
3. 带参无返回值方法
4. 带参带返回值方法
//整型可以向float类型转换 double不能向整型转换  直接写小数是double类型的 （3.2f）代表float类型 小数后面需要跟f

1.1 方法重载：方法名相同  参数列表不同
1.2 参数列表中如果有两个以上的参数，可变参数一定是放在最后的！
1.3 数组作为参数时，是不能将多个值传递给数组的！
1.4 但是数组可以向可变参数传递 ， 一个方法只能有一个可边参数
1.5 可变参数列表所在的方法是最后被访问的。

四、类和对象：

1. 类是模子，确定对象将会拥有的特征（属性）和行为（方法）
2. 属性：对象具有的各种静态特征
3. 对象有什么
4. 方法：对象具有的各种动态行为
5. 对象能做什么
6. 在类中 定义的属性值没有赋予初始值 ：在类中调用，字符串的默认值是null,duble是0.0，整型是0
7. 实例化对象的过程分为两个部分：
        a、声明对象 在栈当中(null)
        b、实列化对象 在堆当中
8.  A 构造方法：
     a.构造方法不能用对象调用，在一创建对象时候构造方法就被系统调用了
     b.构造方法的概述和作用：给对象的数据（属性）进行初始化
     c.构造方法的格式特点 :  构造方法名与类同名相同（大小也要与类名一致）且没有返回值（return）连viod都没有
     d.当没有指定构造方法时，系统会自动添加无参的构造方法
     e.当有指定构造方法，无论是有参、无参、的构造方法，都不会自动添加无参的构造方法。
     f.一个类中可以有多个构造方法    
     g.!!!注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
    B 构造方法的语句格式如下：
public (访问修饰符)（//没有返回值类型）构造方法名（与类名相同）（本身固有的括号:可以指定参数）
            {  初始化代码
        }

9.  调用重载的构造方法 ：this() 调用同一个类中的无参构造  通过this调用构造方法，必须放在方法体内的第一行
10. 1、 private(私有的): 限定只能在当前类内访问
    2、 protected : 允许在当前类、同包子类、跨包子类调用，跨包非子类调用是不允许的
    3、 public ：允许在任意位置访问 
    4、 默认： 允许在当前类、同包子类调用；跨包子类不允许调用；
11.                 this 这个关键字的用法：
    a、this在类中就代表当前对象，可以通过this关键字完成当前对象成员的属性、成员方法和构造方法的调用。
    b、当在定义类中的方法时，如果需要调用该类对象，就可以用this来表示这个对象。也就是说，
       但凡在本类功能内部使用到了本类对象，都用this表示。至于代表那个对象，就看其所在功能被那个对象调用，这样就知道谁在参与运算。
     

五、A 封装：

1. 将类的某些信息隐藏在类的内部，不允许外部程序直接访问
2. 通过该类提供的方法来实现对隐藏信息的操作和访问
3. 隐藏对象的信息
4. 留出访问的接口
    B 封装的特点：
 a: 只能通过规定的方法访问数据
 b: 隐藏类的实例细节，方便修改和实现

六、 a:定义包：

语法：package 包名；
例 ：package com.imooc.animal;
注意： 
1. 必须放在java源文件中的第一行
2. 一个java源文件中只能有一个package语句
3. 包名全部英文小写
4. 命名方式：域名倒叙+模块+功能
      b: 导入包
1. import 包名.类名；
例：
  导入包中全部类：  //注意类的实例化的对象的传参不能用加号需要逗号，在输出语句中必须用加号
  impor com.imooc.*   //访问这个包名下的所有类;
  导入包中指定类：
  impor com.imooc.animal.Cat   // 指定的类;
      c:
    常用系统包
1. java.lang    包含java语言基础的类
2. java.util    包含java语言中各种工具类
3. java.io        包含输入、输出相关功能的类

七、 a、  static 关键字的用法： 静态访问方式：类名.属性（注意这里不能实例化对象）

1. static + 属性---静态/类属性
2. static + 方法---静态/类方法
3. static + 类---不存在
4. static + 方法中的静态局部变量---不存在

静态成员随类加载产生，直至类销毁才回收
     b、  静态方法：
1. 可以直接调用同类中的静态成员
2. 不可以直接调用访问同类中的非静态成员
3. 可以通过实例化对象后，对象调用的方式完成非静态成员调用
     

八、 代码块：

1. 通过{}可以形成代码块
2. 方法内的代码块称为：  普通代码块  //同名变量可以放在不同的代码块当中
3. 类内的代码块称为 ：   构造代码块
4. 构造代码块前+static:  静态代码块 优先于构造代码块的执行
5. 无论实例产生多少对象，静态代码块只执行一次
6. 普通代码块随方法调用执行

九、  A:面向对象的随笔录：

1、 在方法中通过对象作为参数，传递的是他的引用，可以通过引用获取该对象的所有信息
      
      B:继承
1、一种类与类之间的关系
2、使用已存在的类的定义作为基础建立新类
3、新类的定义可以增加新的数据或新的功能，也可以用父类的功能，单不能选择性的继承父类
4、父类 ：基类，子类：派生类

5、方法重写语法规则：
a:返回值类型
b:方法名
c:参数类型 顺序、个数 都要与父类继承的方法相同
       
         6.方法重写与方法重载的比较：
  方法重写：注意//在子类重写父类方法时候 子类的对象调用的方法会调用的是子类当中重写的方法
a:  在满足继承关系的子类当中
    方法名、参数个数、顺序、类型与父类、返回值相同
b： 访问修饰符的限定范围大于或等于父类方法                   

  
  方法重载：
在同一个类当中
方法名相同
参数个数、顺序、类型不同
返回值类型访问修饰符任意
  方法重写：
a:有继承关系的子类当中
b:方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
c: 访问修饰符，访问的范围需要大于等于父类的访问范围 
d:与方法的参数名无关
e:父类的构造方法不允许被继承、不允许被重写  //但是会影响子类对象的实例化
f:当子类与父类同时有相同的方法名（也就是说在子类当中重写父类的方法）这时候我想要调用父类的方法 所有的关键字：super.方法名 +（）

十、 A：  实例化顺序

1继承后的初始化顺序：
             父类对象构造
      父类静态成员    子类静态成员
    （属性(赋值)、构造代码块、构造方法)
             子类对象构造
    （属性（赋值）、构造代码块、构造方法）         
     B:    super（）//里面可以传入参数 调用父类指定的构造方法  注意：必须放在子类构造方法有效代码的第一行
     C:      子类访问父类成员：
访问父类成员方法：super.print();
访问父类属性：      super.name；//  只能在方法内访问属性

十一、    super

1. 子类构造的过程中必须调用其父类的构造方法
2. 如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造发囊发
3. 如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的 构造方法，则编译出错
4. 使用super调用父类指定构造方法，必须在子类的构造方法的第一行
5. 访问修饰符不影响成员加载顺序  // 以类当中的成员位置为加载顺序的
6. 子类构造默认的是调用无参的构造方法
7. 如果子类的构造方法中没有显示标注，则系统默认调用父类无参的构造方法

十二、  this与super

     this：当前类对象的引用   // this()优先调用无参构造的方法
1. 访问当前类的成员方法
2. 访问当前类的成员属性
3. 访问当前类的构造方法
4. 不能在静态方法中使用

     super:  父类对象的引用
1. 访问父类的成员方法
2. 访问父类的成员属性
3. 访问父类的构造方法
4. 不能在静态方法中使用     
              //  注意 构造方法中的调用this 和super 只能出现一个方法 因为都要抢占第一个位置

十三、A: object类:

1、object类是所有类的父类
2、一个类没有使用extends关键字明确标识继承关系，则默认继承object类（包括数组）
3、java中的每个类都可以使用object中定义的方法
4、当重写equals方法时候，比较的是两个对象的数据类型 如果不写 这样默认比较的是两个对象的地址 ，等号比较的地址
      
      B: object类的常用方法：

1、toString  :返回当前对象本省的有关信息，按字符串对象返回
2、equals（）：比较两个对象是否是同一个对象，是则返回true
3、hashCode（）：返回该对象的哈希代码值
4、getClass（）：获取当前对象所属的类信息，返回Class对象

十四 final:

1、final class：该类没有子类 （public final class）修饰类标识不允许被继承
2、final 方法：修饰方法表示不允许被子类重写
   a :final 修饰的方法可以被继承
   b :不能修饰构造方法
3、 final方法局部变量：只要在具体被使用之前进行赋值即可，一旦赋值不允许被修改修饰变量表示不允许被修改
    修饰类当中的成员属性：赋值过程：1定义时候直接初始化，2构造方法中，3构造代码块
方法内部的局部变量 在使用之前被初始化赋值即可，
类中成员变量》只能在定义是或者构造代码块、构造方法中进行初始化设置。
基本数据类型的变量》初始化赋值之后不能更改
引用数据类型的变量》初始化之后不能再指向另一个对象，单指向的对象的内容是可变的    

4、可配合static使用
5、使用final修饰可以提高性能，但会降低可扩展性

十五、         A:注解：

1、jdk1.5版本新引入的一个特性
2、可以声明在包、类、属性、方法、局部变量、方法参数等的前面，用来对这些元素进行说明注释。

            B:注解的分类：
    
    按照运行机制分：      按照来源分：
    源码注解            来自jdk的注解
    编译时注解            来自第三方的注解
    运行时注解            我们自己定义的注解

十六、 单例模式：

   A 要点：
1、某个类只能有一个实例
2、必须自行创建类
3、必须自行向整个系统提供这个实例
   B 实现：
1、只提供私有的构造方法
2、含有一个该类的静态私有对象
3、提供一个静态的公有的方法用于创建、获取静态私有对象
   
   C 单例模式代码实现方案：
    
            饿汉式与懒汉式的比较：
            
a:饿汉式在类加载时就创建实例，第一次加载速度快；
b:懒汉式第一次使用时才进行实例化，第一次加载速度慢
c:饿汉式：空间换时间
d:懒汉式：时间换空间
·        

e:恶汉式线程安全；懒汉式存在线程风险
解决方案：
    1.同步锁       2.双重校验锁
    3.静态内部类   4.枚举
            
    D 单例模式适用场景：

1、创建对象时占用资源过多，但同时又需要用到该类对象
2、对系统内资源要求统一读写，如读写配置信息
3、当多个实例存在可能引起程序逻辑错误，如号码生成器
    

十七、多态：多重形态

 

编译时多态：                    运行时多态

设计时多态             程序运行时动态决定调用哪个方法
 方法重载

必要条件：
a:满足继承关系
b:父类引用指向子类对象

1、向上转型： 父类的引用指向子类
 a: 向上转型又叫做自动转型、隐式转型。向上转型就是父类引用指向子类实例，也就是子类的对象可以赋值给父类的对象
 b: 向上转型是安全的，因为任何子类都继承并接受了父类的方法。
 c: 向上转型的应用 ： 当一个子类对象向上转型父类类型以后，就被当成了父类的对象
    所能调用的方法会减少，只能调用子类重写父类的方法以及父类派生的方法（如set（）、get（）方法）
    而不能调用子类独有的方法。
 d: 父类中的静态方法是不允许被子类重写的。
 

十八、 多态的知识扩展：

1、 多态的实现可以通过向上转型和动态绑定机制来完成的，向上转型实现了将子类对象向上
转型为父类类型，而动态绑定机制能识别出对象转型前的类型，从而自动调用了该类的方法，两者相辅相成。
2、 动态绑定机制：
绑定就是将一个方法调用同一个方法所在的类连接到一起就是绑定。绑定分为静态绑定和动态绑定两种。
静态绑定：在程序运行之前进行绑定（由编译器和链接程序完成的），也叫做前期绑定
动态绑定：在程序运行期间由jvm根据对象的类型自动的判断应该调用那个方法，也叫做后期绑定
  
2、向下转型：
  向下转型、强制类型转换，子类引用指向父类对象，此处必须进行强制转换，可以调用子类特有的方法
  向下转型 可以调用父类当中没有而子类当中独有的方法 而向上转型则不行必须强制过后才行
 
3、 instanceof 运算符
    
/ * instancof 运算符 ：用来判断对象是否可满足某个特定类型实例特征。返回值为true/false
        
 */ 
 PolymorphicAnimal two = new Cat();  //指向cat类型的空间
    if (two instanceof Cat) {
        Cat temp = (Cat) two;
        temp.run();
        temp.eat();
        temp.run1();  // 向下转型 可以调用父类当中没有而子类当中独有的方法 而向上转型则不行必须强制过后才行
    System.out.println("这是可以强制转换的");
    } 
 
 
    注解：！！！如果在父类当中的方法 有static 修饰 这个方法在子类当中是无法被重写的
 

十九、抽象类：

1、在类前面加上一个abstract 修饰符,但是抽象类不允许被实例化，可以通过向上转型，指向子类实例
语法： 例如：
a  :public abstract class Animal
b  :abstract public  class Animal
 
2、抽象类的基本概念：
a:基本概念：
    在面向对象的概念中，所有的对象都是通过类来描述的，但并不是说所有的类都是用来描述对象的，
    当一个类中没有包含足够的信息以描绘一个具体的对象时，这样的类就是抽象类。
 
 抽象方法：
 abstract class 《类名》{
 成员变量
 abstract 方法（）；//抽象方法；
 }
 
3、 抽象类和抽象方法的特点：
a: 抽象方法不允许直接实例化，换句话说抽象类不能创建对象，它只能作为其他类的父类。但可以通过向上转型，指向实例化
b: 抽象方法只有声明，不能有实现，也就是仅有方法头，而没有方法和操作实现。
例：abstract double area();
 
4、定义抽象类的意义在于：
a: 为其子类提供一个公共的类型（父类引用指向子类对象）；
b: 封装子类中的重复内容（成员变量和方法）；
c: 将父类设计成抽象类后，既可借由父子继承关系限制子类的设计随意性，在一定程度上避免了无意义父类的实例化

5、 重点注意
a: 含有抽象方法的类，只能被定义成抽象类  
b: 但是抽象类不一定包含抽象方法 
c: 抽象类中的成员方法可以包括一般方法和抽象方法
d: 抽象类不能被实例化，即使抽象类里面不包含抽象方法，这个抽象类也不能创建实例。
e: 抽象类的构造方法主要是用于被其子类调用 
f: 一个类继承抽象类后，必须实现其所有抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。 
g: 即使父类是具体的，但其子类也可以是抽象的。如object是具体的，单可以创建抽象子类
h: static final private 不能与abstract并存
i: 接口访问修饰符： public 默认
j: 接口中抽象方法可以不写abstract关键字
k:   // default : 默认方法 可以带方法体
    default void connect(){
        System.out.println("我是接口中的默认连接");
    }
l: // 获取内部类对象实例，方式一：new 外部类.new 内部类s
m: //  获取内部类对象实例，方式2：外部类对象.new Heart() 
n: 内部类通常有一个获取对象的方法，用这个方法实现 获取内部类：获取内部类对象实例方案三，外部类对象.获取方法

6、成员内部类：
a:    内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
b:    内部类的访问修饰符，可以任意，但是访问范围会受到影响
c:    内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的
d:    可以使用外部类.this.成员的方式，访问外部类中同名的信息          
e:    外部类访问内部类信息，需要通过内部类实例，无法直接访问
f:    内部类编译后.class文件名： 外部类$内部类.class
 
7、静态内部类：
a:静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例 
b:
     * 1、静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例 
     * 2、静态内部类对象实例时，可以不依赖于外部类对象
     * 3、可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员 
     * 4、当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
     * 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式； 
     * 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式；
     */

8、通过throws抛出异常时，针对可能出现的多种异常情况，解决方案：
a: throws后面接多个异常类型，中间用逗号分隔 
b: 通过try..catch包含throw语句     自己抛自己处理
c: 通过throws在方法声明出抛出异常类型--谁调用谁处理--调用者可以直接处理，也可以继续往上抛
  例如：
  package exception;
import java.util.Scanner;
public class Host {
    public static void main(String[] args){
        testAge();
    }
    public static void testAge(){
        try {
            System.out.println("请输入年龄");
            Scanner input = new Scanner(System.in);
            int age = input.nextInt();
            if(age<18||age>80){
                throw new Exception("18岁以下，80岁以上必须由亲人陪同");  //主动抛出一个异常
            }else {
                System.out.println("欢迎来到天堂");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
}

9、异常链：
a:有时候我们会捕获一个异常后在抛出另一个异常
b:顾名思义就是：将异常发生的原因一个传一个串起来，
即把底层的异常信息传给上层，这样逐层抛出。

二十、集合框架的体系结构：

 1、Collection:类的对象 包含三个接口
 A：List : 
    list 是元素有序并且可以重复的集合，称为序列
    list 可以精确的控制每个原始的插入位置，或删除某个位置的元素
    list 的两个只要实现类是ArrayList和LinkList
    
    a:存放的内容有序，允许重复。
    b：ArrayList : 动态增长数组
    c: LinkList : 列表
 B: Qeeue ： 
    a:存放的内容有序，允许重复。
    b：LinkList : 列表
    
 C：Set ： set是元素无序并且不可以重复的集合，被称为集
    a:存放的内容有无序，不允许重复。
    b：HashSet
 
 2、Map:
    a:HashMap:也就是哈希表
    
3、ArrarList：

a：ArrarList底层是由数组实现的
b: 动态增长，以满足应用程序的需求
c: 在列表尾部插入或删除数据非常有效
d: 更适合查找和更新元素
e: ArrayList 中的元素可以为null

4、HashSet:
a：hashset是set的一个重要实现类，称为哈希集
b: hashset中的元素无序并且不可以重复
c: hashset中只允许一个null元素
d: 具有良好的存取和查找性能

5、 Interator（迭代器）:
a: Interator 接口可以以统一的方式对各种集合元素进行遍历
b: hasNext()方法检测集合中是否还有下一个元素
c: next() 方法返回集合中的下一个元素

 

二十一、java的输入输出流

A:输出流：a：流就是指一连串流动的字符，一先进先出的方式发送信息的通道。
          b: 文件输入，读
          c：文件输出，写
B:输出流：

C：绝对路径：是从盘符开始的路径。
D: 相对路径：是从当前路径开始的路径。

E：        // 创建file对象  的几种方式
//    一、    File file = new File("c\\imooc");
//        File file1 = new File(file,"io\\score.txt");  
//    二、
        File file = new File("c:\\imooc\\io\\score");  

// 创建目录
        File file2 = new File("c:\\imooc\\set\\HashSet");
        if (!file2.exists()){
            file2.mkdirs();  //多个目录运用mkdirs 后面加s
        }
        if (!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
F: 字节流
a:字节输入流
b:字节输出流

G:FileInputStream
 a: 从文件系统中的某个文件中获得输入字节流
 b: 用于读取诸如图像数据之类的原始字节流

H:复制图片的操作： 前提把一张图片放在工程目录下面
package copyimage;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyPhoto {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("pengliang.jpg");
            FileOutputStream fos = new FileOutputStream("pengliangcopy.jpg");
            int n = 0;
            byte[] b = new byte[1024];  // 用数组来存储字节
            while ((n = fis.read(b)) != -1) {
                fos.write(b, 0, n);  //直到读到最后一个字节  只要不等于-1一直读
            }
            fis.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

I:字符字节的转换：（imooc 为当前工程下的文件）
package fileDemo;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class ReaderDemo {
    public static void main(String[] args){
        try {
            FileInputStream fis = new FileInputStream("imooc");
            InputStreamReader fos = new InputStreamReader(fis); // 读取的是输出流的对象
            int n = 0;
           // 读取文件的两种操作 字符字节的转换
            while((n=fos.read())!=-1){
                System.out.print((char)n);

            }
            //  读取文件的第二种操作 
    //       char[] b = new char[100];
     //    while ((n=fos.read(b))!=-1){
//                String s = new String(b); //读到的字节数 转换为 字符串输出
//                System.out.println(s);
//            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}