java所有知识，全部笔记，刚开始不知道叫啥，持续更新20天

以一个大家喜闻乐见JAVA程序开始我的旅行。

public class helloworld {   //关键字class表明java程序中全部内容都包含在这个类中     
    public static void main(String[] args) {   //关键字public称为访问修饰符(access modifier)
        System.out.println("hello,world");
    }
}

Java这个语言很非凡。 
一、你可以说它是编译型的。因为所有的Java代码都是要编译的，.java不经过编译就什么用都没有。 
二、你可以说它是解释型的。因为java代码编译后不能直接运行，它是解释运行在JVM上的，所以它是解释运行的，那也就算是解释的了。 

定义： 
编译型语言：把做好的源程序全部编译成二进制代码的可运行程序。然后，可直接运行这个程序。 
解释型语言：把做好的源程序翻译一句，然后执行一句，直至结束！ 
区别： 
编译型语言，执行速度快、效率高；依靠编译器、跨平台性差些。 
解释型语言，执行速度慢、效率低；依靠解释器、跨平台性好。 
个人认为，java是解释型的语言，因为虽然java也需要编译，编译成.class文件，但是并不是机器可以识别的语言，而是字节码，最终还是需要 jvm的解释，才能在各个平台执行，这同时也是java跨平台的原因。所以可是说java即是编译型的，也是解释型，但是假如非要归类的话，从概念上的定义，恐怕java应该归到解释型的语言中。 
附： 
编译型的语言包括：C、C++、Delphi、Pascal、Fortran 
解释型的语言包括：Java、Basic、javas cript

1.1:注释

介绍：

java中的注释不会出现在可执行程序中，可以根据大家所需所想的地方添加注释，在java中有三种标记注释的方式。

格式：

名称	代码	快捷键	功能介绍
单行注释	//	//	单行注释可以注释到一行代码，内容不参加编译
多行注释	/*-------*/	ctrl+Shift+/	多行注释可以注释到多行代码，内容不参加编译
文档注释	/**-------*/	/**-------*/	文档注释主要应用在对代码的一些描述，代码块所实现的功能以及一些必要说明

:

//System.out.println("单行注释");

/*System.out.println("我是");
System.out.println("多行注释");*/

/**System.out.println("我是");
System.out.println("文档");
System.out.println("注释");*/

1.2:数据类型

介绍:

java是一种强类型语言，也是一门静态编程语言,这就意味着必须为每一个变量声明一种类型，在java中，一共有8种基本类型（primitive type）,其中有4种整形，2种浮点类型，一种字符类型char，一种用于标识真假的boolean。

在通常情况下，int类型最常用。如果想要表示整个地球的居住人口，就需要使用long类型，byte和short类型主要用来特地的应用场合，例如，底层的文件处理或者存储空间很宝贵时的大数组，

格式：

 八大数据类型如下：

1.3:变量和常量

介绍：

与所有程序设计语言一样，java也使用变量来存储值，常量就是值不变的变量。

在Java中，每个变量都有一个类型(type),在声明变量时，先指定变量的类型，然后是变量名。

变量未初始化报错:

声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量的值，

例如：java编译器任务下面的语句序列是错误的。

变量语法:

第一种

数据类型 变量名称 ;

变量名称 = 赋值；

第二种

数据类型 变量名称 = 赋值;

代码:

常量介绍:

关键字final(最终的)表示这个变量只能被赋值一次,一旦被赋值之后就不能再更改，习惯上,常量名使用全大写。

1.4:运算符

介绍:

运算符用于连接值，在java中，使用算数运算符

2.1:判断

java中的条件语句：

1、if语句：

      格式：if（判断的条件）{

                           语句1；

                  }

      解读：如果条件符合的时，程序则执行语句1.不符合条件接收程序。

代码：

public class day_1单if判断 {
    public static void main(String[] args) {
        int a = 3 ;
        int b = 1 ;
        if (a > b) { //如果3大于1,进行执行输出语句，如果条件不对不执行输出语句
            System.out.println("条件成功"); //条件成功
        }
    }
}

2、if(){}else{}语句：

      格式：

             if(判断条件){

                语句块1；

               }else{

                语句块2；

             }

       解读：if(){}else{}语句是分为两种情况，当条件成立时，执行语句块1，当条件为假时，执行语句块2.

代码：

public class day_2if判断 {
    public static void main(String[] args) {
        int a = 0 ;
        int b = 1 ;

        if (a >= b){ //如果条件符合，执行语句块1
            System.out.println("语句块1");
        }else{ //如果条件不符合，执行语句块2
            System.out.println("语句块2");
        }

    }
}

3、if(){}else if{}else{};

      格式：if(判断语句){

                     语句块1；

               }else if(){

                     语句块2；

              }

              ...{

           } else{

                    语句块n;

            }

          解读：这个条件判断语句使用与多种的条件的场合。

2.2:选择

switch-case选择结构由switch ，case， （break），（default）组成

其中，break后要加表达式

然后让表达式与下面几个case里的情况匹配，匹配成功才会执行

下面是具体结构

switch(表达式){

case 常量1:

语句1；

(break;)

case 常量2:

语句2；

(break;)

case 常量3:

语句3；

(break;)

case 常量4:

语句4；

(break;)

......

default:

语句n；

}

结论：最终执行的方法体是什么呢？匹配上的case的冒号开始，一直到break为止，之间的case条件忽略，语句会执行。

因为定义的int型变量是a，与case里的第一个匹配成功，所以执行第一个case中的语句

输出结果为A

break是终止语句即执行完第一个case中的语句后终止结构

如果没有break的话会从第一个case往后将所有的case情况全部执行一边即输出结果为

ABCDE叼毛

如果word为b，输出结果为   BCDE叼毛

2.3:for循环

for 循环语句的一般形式为：

1. for (表达式1; 表达式2; 表达式3){

2.         语句;

3. }

首先要强调两点：

1) 表达式1、表达式2和表达式3之间是用分号;隔开的，千万不要写成逗号。

2) for(表达式1；表达式2；表达式3)的后面千万不要加分号，很多新手都会犯这种错误——会情不自禁地在后面加分号。

因为 for 循环只能控制到其后的一条语句，而在C语言中分号也是一个语句——空语句。所以如果在后面加个分号，那么 for 循环就只能控制到这个分号，下面大括号里面的语句就不属于 for 循环了。

下面来看看它的执行过程：

1. 求解表达式1。

2. 求解表达式2。若其值为真，则执行 for 语句中指定的内嵌语句，然后执行第3步；若表达式2值为假，则结束循环，转到第5步。

3. 求解表达式3。

4. 转回上面第2步继续执行。

5. 循环结束，执行 for 语句下面的语句。

从这个执行过程中可以看出，“表达式1”只执行一次，循环是在“表达式2”“表达式3”和“内嵌语句”之间进行的。

for语句最简单的形式是：

1. for (循环变量赋初值; 循环条件; 循环变量增值)

2. {

3.     语句;

4. }

增强for循环

为什么需要增强for循环呢？
简化数组和集合的遍历。
想要使用增强for循环必须先要了解它的格式
增强for循环的格式

for(数据类型 变量名 : 数组或者集合对象){ //循环体，变量即元素 }

注意：
增强for的底层依赖的是迭代器。
也就是说增强for就是迭代器的简写形式。
下边我们通过案例演示一下：

3.1:方法

介绍:

Java语言中的“方法”（Method）在其他语言当中也可能被称为“函数”（Function）。对于一些复杂的代码逻辑，如果希望重复使用这些代码，并且做到“随时任意使用”，那么就可以将这些代码放在一个大括号“{}”当中，并且起一个名字。使用代码的时候，直接找到名字调用即可。

首先方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。
 

首先了解关于方法的两个概念：

1.参数：是指进入方法中的数据，有了这些数据，方法才能执行逻辑。

2.返回值：是指从方法中出来的数据，也就是方法执行之后的最终结果数据。

目前定义方法的基本格式：

修饰符   返回值类型  方法名称(参数类型   参数名称){undefined

方法体

return    返回值；

}

调用方法的语法格式:

第一种方法：类名.方法名（参数列表）

第二种方法:方法名（参数列表）

4:数组

简介：

数组我称之为容器,将多个数据存储在一起,每个数据称之为容器的元素,数组就是存储多个元素的容器，数组的长度固定,多个数据的数据类型要一致。

特点:

1.数组是一种引用数据类型

2.数组当中的多个数据，类型必须统一

3.数组的长度再程序运行期间不可改变

5:面向对象

在了解面向对象编程之前首先要先了解编程中两大思想：

●面向过程
●面向对象

一、编程中两大思想
（一）、面向过程编程POP(Process-oriented programming)

面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候再一个一个的依次调用就可以了。

举个栗子:将大象装进冰箱,面向过程做法：
①.打开冰箱门 

②.大象装进去 

③.关上冰箱门

面向过程，就是按照我们分析好了的步骤，按照步骤解决问题。

●优点: 性能比面向对象高,适合跟硬件联系很紧密
的东西,例如单片机就采用的面向过程编程。
●缺点:没有面向对象易维护、易复用、易扩展
 

（二）、面向对象编程OOP (Object Oriented Programming)

面向对象是把事务分解成为-一个个对象,然后由对象之间分工与合作。
举个栗子:将大象装进冰箱,面向对象做法。
先找出对象,并写出这些对象的功能: 
1.大象对象
●进去
2.冰箱对象
●打开
●关闭
3.使用大象和冰箱的功能
面向对象是以对象功能来划分问题，而不是步骤。

●优点: 易维护、易复用、易扩展,由于面向对象有
封装、继承多态性的特性,可以设计出低耦合的
系统，使系统更加灵活、更加易于维护
●缺点:性能比面向过程低
 

类和对象

简介：

-什么是对象：

万物皆对象，客观存在的事物皆为对象，大到名胜古迹，小到生活中小物品。

-什么是面向对象：

从字面上分析，就是我们人面向一个对象，可以理解为关注的对象

 而对于计算机来讲，他形象比喻了我们人他关注一个具体信息。

-面向对象编程，面向一个具体对象来进行操作，。

-什么是类：

类是对现实生活中一类具有共同属性和行为的事物的抽象

属性：变量

行为：方法

-类的特点：1.类是对象的数据类型

                   2.类是具有相同属性和行为的一组对象的集合

-什么事对象的属性：

属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值

             

-什么是对象的行为：

行为：对象能够执行的操作，而行为可以理解为对象能够做什么

-类和对象的关系

类：类是对现实生活中一类具有共同属性和属性的行为事物的抽象

对象：是能够看的到摸的着的真正存在的实体

 -类的定义

类的重要性：是java程序的基本组成单位，我们必须先写一个类才能有对象，

-类是什么

是对现实生活中一类具有共同属性和行为的事物抽象，确定对象将会拥有的属性和行为，可以理解为对象有什么，可以用属性来表示，对象能够做什么，可以用行为来表示

-类的组成：属性和行为

属性：在类中通过成员变量来体现（类中方法外的变量）

行为：在类中通过成员方法来体现（类中方法外的方法，和前面成员方法相比是去掉static关键字即可）

-类的定义

封装 继承 多态 

一、封装

        封装从字面上理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型，将数据和基本数据封装在一起，使其构成一个不可分割的个体，数据被保护在抽象数据类型的内部，尽可能的隐藏内部的细节，只保留一些对外接口使之与外部发生的联系，系统的其他对象只能通过包裹在数据外面的已经搜全的操作与这个封装对象进行交流和交互，也就是用户无需知道对象内部的细节，但可以通过该对象对外提供的接口来访问对象,允许其它类访问的，就设置为public；允许子类访问的，就设置为protected；只能自己访问的，就设置为private。

        对于封装而言，一个对象它所封装的是自己的属和方法，所以它不需要依赖其他的对象就可以完成自己的操作，使用封装有三大好处。

1.良好的封装能够减少耦合

2.类内部结构可以自由修改。

3.可以对成员进行更准确的控制。

  封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问，但是如果一个类没有提供外界访问的方法，那么这个类也没有什么意义了。

  封装可以使我们容易地修改类内部实现，而无需修改使用该类客户代码，就可以对成员变量进行更准确的控制。

 

 二.继承

2.1继承概述

        继承使用已存在的类定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性的继承父类，通过使用继承我们能够非常方便的复用以前的代码，能够大大的提高开发的效率。

        继承所描述的是“is-a”的关系，如果有两个对象A和B，若可以描述为“A和B”,则可以表示A继承B，其中B是被继承者称之为父类或者超类，A是继承者称之为子类或者派生类。

        实际上继承者是被继承者的特殊化，它除了拥有继承者的特性外，还拥有自己独立的特性，例如猫有抓老鼠，却没有其他的特性，，同时在继承关系中，继承者完全可以替换被继承者。

1.子类拥有父类非private得属性和方法

2.子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法

2.2 构造器
    通过前面我们知道子类可以继承父类的属性和方法，除了那些private的外还有一样是子类继承不了的---构造器。对于构造器而言，它只能够被调用，而不能被继承。 调用父类的构造方法我们使用super()即可。

    构建过程是从父类“向外”扩散的，也就是从父类开始向子类一级一级地完成构建。而且我们并没有显示的引用父类的构造器，这就是java的聪明之处：编译器会默认给子类调用父类的构造器。

    但是，这个默认调用父类的构造器是有前提的：父类有默认构造器。如果父类没有默认构造器，我们就要必须显示的使用super()来调用父类构造器，否则编译器会报错：无法找到符合父类形式的构造器。

    对于子类而已,其构造器的正确初始化是非常重要的,而且当且仅当只有一个方法可以保证这点：在构造器中调用父类构造器来完成初始化，而父类构造器具有执行父类初始化所需要的所有知识和能力。

对于继承而言，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器，而且必须是在子类构造器中做的第一件事(第一行代码)。

2.3 protected关键字
    private访问修饰符，对于封装而言，是最好的选择，但这个只是基于理想的世界，有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

    对于protected而言，它指明就类用户而言，他是private，但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的。

三、多态

3.1 多态综述  
    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

所以对于多态我们可以总结如下：

   指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

    对于面向对象而言，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

3.2 多态的实现条件
      在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。

Java实现多态有三个必要条件：继承、重写、向上转型。

    继承：在多态中必须存在有继承关系的子类和父类。

    重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

    向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

    对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

3.3 实现形式
   在Java中有两种形式可以实现多态：继承和接口。
3.2.1、基于继承实现的多态
    基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

    基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

    如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

3.2.2、基于接口实现的多态
    继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

    在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

    继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

public class A {  
    public String show(D obj) {  
        return ("A and D");  
    }  
  
    public String show(A obj) {  
        return ("A and A");  
    }   
  
}  
  
public class B extends A{  
    public String show(B obj){  
        return ("B and B");  
    }  
      
    public String show(A obj){  
        return ("B and A");  
    }   
}  
  
public class C extends B{  
  
}  
  
public class D extends B{  
  
}  
  
public class Test {  
    public static void main(String[] args) {  
        A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();  
        D d = new D();  
          
        System.out.println("1--" + a1.show(b));  
        System.out.println("2--" + a1.show(c));  
        System.out.println("3--" + a1.show(d));  
        System.out.println("4--" + a2.show(b));  
        System.out.println("5--" + a2.show(c));  
        System.out.println("6--" + a2.show(d));  
        System.out.println("7--" + b.show(b));  
        System.out.println("8--" + b.show(c));  
        System.out.println("9--" + b.show(d));        
    }  
}  

运行结果：

分析如下：

①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B”呢？

    当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。（但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
上面程序中的A,B,C,D存在如下关系：

分析4：

    a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

分析5：

    a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。
分析8：

    b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

    按照同样的方法我也可以确认其他的答案。
   当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：a2.show(b)；

    这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。

代码：  类的定义

 -对象的使用

 代码：  方法的使用

 案例：学生

需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量

          成员方法的使用。

分析如下：这个学生有那些成员变量和成员方法，学生应该有姓名年龄和家庭住址等等，学生有                      哪些成员方法，学生要学习，学完之后要作业等等。

代码： 

-成员变量和局部变量

什么是成员变量和局部变量

-封装

0.1：private关键字

        1.是一个权限修饰符

        2.可以修饰成员（成员变量和成员方法）

        3.作用是保护成员不被别的类使用，被private关键字修饰的成员只能在本类中进行访问

针对private修饰的成员变量，如果需要被其他类使用，提供响应的操作

        1.提供"get变量名()"方法，用于获取成员变量的值，方法用public修饰

        2.提供"set变量名()"方法，用于设置成员变量的值，方法用public修饰

例子：107

列子：解决private私有化关键字设置取出值方法

-private关键字使用

一个标准类的编写：

1.把成员变量用private关键字进行修饰

2.提供对应的getAge()和setAge() 方法

0.2:this关键字

1.this修饰的变量用于指代成员变量。

        .方法的形参如果与成员变量同名，不带this修饰的变量指得是形参，而不是成员变量。

        .方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。

        .什么时候用this呢？解决局部变量隐藏成员变量。

2.this代表所在类的引用

        .记住：方法被那个对象调用，this就代表那个对象。

代码：this关键字

 

0.3:封装

1.封装概述

        .是面向对象三大特征之一（封装，继承，多态）

.       .是面向对象编程语言对客观世界的模拟，客观世界成员变量都是隐藏在对象内部，外界是无法进行操作的。

2.封装原则

        .将类的某些信息隐藏在类内部，不可以被外部程序被访问，而是通过类提供的方法来实现隐藏信息的操作和访问，成员变量时private,提供对应的gatAaa()和setAaa()方法。

3.封装的好处

        .通过方法来控制成员变量的操作，提高代码的安全性，把代码进行封装，提高代码的复用性。

0.4：构造方法

1.构造方法的概述

        .构造方法是一种特殊的方法

        .作用：是创建对象

        .功能：主要完成对象数据的初始化

-main方法中我们做了一件事，s1=newStudent(),这是在创造一个对象，重点看newStudent后面的小括号，一个东西后面跟着一个小括号，我们说他就是一个方法，所以说用红线标注，他其实也是一个方法，这个方法比较特殊，他的名字是一个类名，这种就叫做构造方法， 

-代码，无参构造

-注意事项

1.构造方法的创建

        .如果没有定义构造方法，系统会给出一个默认的无参构造方法。

        .一旦你给给出构造方法，系统将会不在提供无参构造，如果你要使用，必须手动给出。 

2.构造方法的重载

        .如果自定义了带参构造方法，还要使用无参数构造方法，就必须在写一个构造方法。

3.推荐的使用方式

        .无论是否使用，都手工书写无参数构造方法。

代码：有参和无参构造方法

-类

1.标准类制作

一个正常标准类的规范：

2.API

1.1API概述

API(Application Programming Interface)：应用程序编程接口 

 1.2如何使用帮助文档

 

通过构造对象来创建对象

重要的看的是方法名，参数，返回值

我们说了java.lang包里不需要导包 

第二步需要看类的描述信息，看到这句我就知道是是生成随机数。

第三步是创建对象，所以要看构造方法，一个无参一个有参

第四步是看方法，方法有很多 

1.3API使用练习

需求：按照帮助文档的使用步骤学习Scanner类的使用，并实现键盘录入一个字符串，最后输出控制台上。

代码：

注意：

调用方法的时候，如果方法有明确的返回值，我们用变量接收，可以手动完成，也可以使用快捷方式完成（Ctrl+Alt+V）

2.String类

在Java下lang包，不需要导包

概述：

0.1：String类代表java.lang包下，所以使用的时候不需要导包

0.2：String类代表字符串，java程序中的所有字符串文字（例如“abc”）都被实现为此类的实例，也就是说。java程序中所有的双引号字符串，都是String类的对象

字符串的特点:

0.1：字符串不可变，他们的值在创建后不能被更改。

0.2：虽然String的值是不可变得，但是他们可以被共享。

0.3：字符串效果上相当于字符数组（char[]），但是底层原理是字节数组（byte[]）

String构造方法：

 String 对象的特点

我们有两种方式得到String对象，一种是通过构造方法，一种是赋值方法,这两种有什么不同？

 

在内存池中做了一些什么:

0.1：首先程序先从main方法执行，main方法会加载到栈内存。

0.2：进来之后创建一个字符数组，空间的地址是001，把001给了chs，通过001就指向了内存空间。

0.3：创建第一个字符串对象，new之后会有一个地址是002，把002这个地址赋值给s1。

0.4：创建第二个字符串对象，new之后会有一个地址是003，把003这个地址赋值给s2。

0.5：进行比较，s1的地址是001，s2的地址是002，结果为false。

字符串的比较 :

 

用户登录案列：

需求：已知用户名和密码，请用程序实现模拟用户登录，总共给三次机会，登录之后，给出相应的提示。

思路：

1.已知用户名和密码，定义两个字符串标识即可。

2.键盘录入要登录的用户名和密码，用Scsnner实现。

3.拿键盘输入的用户名，密码和已知用户名，密码进行比较，给出相应的提示，字符串内容比较，用equals()方法实现。

4.用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功实现，用break结束循环。

代码如下：

遍历字符串案例： 

需求：键盘录入一个字符串，使用程序实现在控制台遍历字符串。

思路：

1.键盘录入一个字符串，用Scanner实现。

2.遍历字符串，首先能够获取到字符串中的每一个字符。

        *public char charAlt(int index):返回指定索引处的char值，字符串的索引也是从0开始的。

3.遍历字符串，其次能够获取到字符串的长度。

        *public int length():返回此字符串的长度。

        *数组的长度：数组名.len

        *字符串的长度：字符串对象.length

4.遍历字符串的通用格式

for(int i = 0;i< s.length();i++){

        s.charAt(i); //就是指定所引出的字符值

}

代码：

 统计字符次数案例：

需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)。

思路：

1.键盘录入一个字符串，用Scanner实现。

2.要统计三种类型的字符个数，需定义三个统计变量，初始值为0。

3.遍历字符串，得到每一个字符。

4.判断该字符属于那种类型，然后对应类型统计变量+1。

        加入ch是一个字符，我要判断它属于大写字母，还是小写字母，还是数字，直接判断该字符是否在对应的范围即可。

*大写字母：ch >= 'A' && ch <= ‘Z’ 

*小写字母：ch >= 'a' && ch <= 'z'

*数字：ch >= '0' && ch <= '9'

5.输出三种字符的个数。

 代码：

 拼接字符串案例：

需求：

定义一个方法，把Int数组中的数据按照指定的格式拼接城一个字符串返回，调用该方法，并在控制台输出结果。例如为int[]arr = [1,2,3],执行方法后输出结果为：[1,2,3]

思路：

1.定义一个int类型的数组，用静态初始化完成数组元素的初始化。

2.定义一个方法，用于把int数组中的数据，按照指定格式拼接成一个字符串返回，返回值类型String,参数列表int[] arr

3.在方法中遍历数组，按照要求进行拼接

4.调用方法，用一个变量接收结果

5.输出结果

代码：

 字符串翻转案列：

需求：

定义一个方法，实现字符串翻转，键盘录入一个字符串，调用该方法后，在控制台输出结果，例如：键盘录入abc,输出结果cba

思路：

1.键盘录入一个字符串，用Scanner实现

2.定义一个方法，实现字符串反转，返回值类型String,参数String s

3.在方法中把字符串倒着遍历，然后每一个得到的字符串拼接成一个字符串并返回

4.调用方法，用一个变量接收结果

5.输出结果

 通过帮助文档查看String中的方法

StringBuilder

 

 

概述：

StringBuilder是一个可变的字符串类，我们可以把他看成是一个容器，这里的可变值得是StringBuilder对象中的内容是可变的。

String和StringBuilde的区别

*String:内容是不可变的。

StringBuilder:内容是可变的。

StringBuilder构造方法

代码：

 StringBuilder的添加和反转方法

代码：

StringBuilder和String相互转换

因为StringBuild中有两个好用的方法，String要想直接使用是使用不了的，要想使用需要进行转换。

 代码：

1.this,static,代码块

代码如下：

 

这个level代表的局部变量，this.level代表全局变量，将右侧的局部变量赋值给左侧的全局变量。 

 

如果我们在这个地方调用了构造函数，对应的

会在这里调用无参构造，这个时程序就会发现

这个this，会调用 

说白了就是在上个方法中调用了这个方法，调用下面这个方法，并且把值赋进去。

这种形成了一个构造链 

if(结果为boolean类型得条件){
}

this static 继承

this指的是当前对象
因为在外面我们可以直接拿对象的引用
person p = new Person();
因为在外面我们可以直接拿对象的引用
因为在这个p代表一个引用，他会指向new person这个地方创建的对象
但是在类的里面我们可以用this来代替
this是个变化的引用

this有两种用法
1.this.属性或者是this.方法()
2.this()表示调用构造方法,可以用它形成构造链
    但是这个代码只能写在构造方法中，并且只能写在第一行

快速封装：alt+insert(ihs)

static代表静态的，是属于类的，不是属于对象的，我们每创建对象就会在内存里面开辟一个空间，将这个对象放在这个空间
只占用一份内存空间，他与对象无关，static可以修饰属性和方法
static修饰的属性或者是方法一定出生早与我们对象，先有模板再有对象
他其实是属于类的东西

它可以通过类名直接访问，也可以通过对象名访问

它存在的问题
1.因为它是类级别的，所以static的方法中不能包含非static
2.它修饰的是所有对象共享的，无法区别，不是每个对象特别的属性

static的特点
1.static修饰的属性及方法能被非static调用
2.static修饰的属性及方法不能调用非static

jvm(java虚拟机)加载类的原则
先静后动
先属性后方法

普通：先代码块，在属性，在方法
static:先代码块，在属性，在方法

静态代码块：

所谓的代码块就是一段独立的代码空间，那什么是静态代码块呢？说白了，静态代码块就是用static修饰的代码块，关于静态代码块的概念不多说，不过你需要知道它的一个特点，那就是

随着类的加载而执行，而且只执行一次

用代码验证静态代码块随着类的加载而执行，且执行一次

由输出结果我们可以看见，最先被打印的是静态代码块的输出内容，这就说明在加载类的时候是先执行了静态代码块的内容，随后调用了类中的方法，当再次创建实例调用方法的时候只有方法被调用了，而静态代码块不再执行，因此，静态代码块的特点是随着类的加载而执行，而且只执行一次！

2.继承

银行卡：有属性：卡号，密码（在创建是就应该有默认值），存款金额

1.卡号允许查看，但不可以修改

2.密码不许查看，但可以修改

3.取款要输入取款金额，密码，卡号

a:如果余额小于取款金额，不能取款

b:如果密码或者卡号错误也要给提示

c:取款完了要返回取款金额，还要修改余额

d:可以查看当前余额(要提供卡号及密码)

修改银行卡的例子，保证其中使用this的两种方法(this.成员,this());

4.统计总共产生了多少张卡

5.加入一个限制，限制卡只可以产生3张对象，比如3个对象

那么第四个对象开始创建的结果为null;

注意:无论创建多少对象，这些对象创建的时机时不可预测的

2.set集合

数组的弊端，在数组中开辟一个空间开辟一个5个空间但是超过，数组的长度是固定

但是如果要存放一个6，会把原来的数组干掉，会重新开辟一个数组

java给提供一个collection集合类，可以存放任意对象，长度可以改变，会随着元素增加而增加

数组和集合的区别，数组可以存储基本数据类型也可以存储引用数据类型，基本类型存储的是值，引用数据类型存储的是地址值

集合只能存储引用数据类型，也就是对象

 

迭代器方法

2.list集合

右侧为Arraylist，它的父类是list集合

数组是查找修改快，增删漫(牵一发而动全身)

 通过Index索引增加，在第二个位置加上一个10,那后边都需要往后边去移动

如果删除呢，那后面会往前走

B:链表LinkedList

查询慢，修改也慢

增删快

画图分析：

假如赵六需要找张三，他俩不认识，需要通过王五找到李四，李四找到张三 

 其实就是从老集合拷贝到新集合去,把拷贝进新集合的元素判断一下是否已经含有相同的,如果有就不放进来

前段是ur列表，本身放在集合中遍历出来

 结果：

 结果输出还是重复值，看一下contains方法

 底层用的是equals方法比较的

//object默认是对比对象的内存地址，即使名字和年龄一样，地址不一样的，也会被集合添加进行
//在我们眼里张三 25  张三 25是一个人，但是他不怎么认为 这个张三有可能是01285  那个是05465

所以我们要做的是在student这个类中重写equals方法

3.集合框架

 泛型

集合框架里面有一个泛型类和泛型方法
//泛型标记 E T K N ?
E:elepent:在容器当中使用，表示一个元素
T:tvpe:表示普通的java的类
K:key:键
V:value:值
N:number:数值类型
?:表示不确定的java类型

set集合

 

 

 

mysql

安装流程图

第一步先进行解压

第二步访问mysql中的bin目录，

cmd通过管理员身份去运行

 mysql装成功

SQLyog

会出现乱码

MySql解压版本的安装

1. 生成data目录

通过Win+R快捷键输入cmd进入DOS命令行中切换到目录D:\Program Files\mysql-8.0.12-winx64\bin下运行一下:

mysqld --initialize-insecure --user=mysql

操作图示:

  ---->   

2、注册服务：mysqld install MySQL;

运行上面，如果出现：mysql Install/Remove of the Service Denied!

进入系统盘找到C:\Windows\System32\  打开cmd.exe程序的时候右键选择“用管理员身份打开”。

 3、启动服务：net start mysql;

如果服务启动不了，初始化mysql输入：mysqld initialize 回车，如果还是无效重复2

4、无密码登录数据库：mysql -u root -p  这个时候会让你Inter Password：直接回车。

5、那就是要设置登录密码(mysql默认是没有登录密码的)：

格式：alter user user() identified by "新的密码";

列如：alter user user() identified by "123456";

8、SQLyon登录问题:

配置新连接报错：错误号码 2058，是sqlyog的默认编码和系统自带的不一样,SQLyon解析不了。 解决方法：windows 下cmd 登录 mysql -u root -p 登录你的 mysql 数据库，然后赋值下面行SQL语句执行： ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';

MySql的卸载

1. 先停止mysql服务

1. 使用快捷键Win+R里面进入regedit注册表：

找到KEY_LOCAL_MACHINE-->SYSTEM-->ControlSet001-->Services里面找到MYSQLD开头相关文件夹的删除 HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\eventlog\Application\MySQL 文件夹 HKEY_LOCAL_MACHINE\SYSTEM\ControlSet002\Services\eventlog\Application\MySQL 文件夹(如果没有ControlSet002就忽略)。 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\eventlog\Application\MySQL 的文件夹(如果没有ControlSet002就忽略)。 上面几栏 如果没有相应的文件夹，就不用删除了。

1. 去mysql安装目录下删除mysql的安装文件夹
2. 显示隐藏文件夹，在系统盘里面找到C:\ProgramData文件夹里如果有mysql文件夹则删除

5.重启系统

刚开始装sql有一个开机自启动

1.电脑右键管理

2.

 3.

可以改为手动

如果连接不上mysql，考虑一下服务没打开 

 数据库在data下

 数据库里面有一个表，里面有student,表里面有id name 101,java程序会通过一个jar包进行连接，jar包就是连接数据库驱动，就可以跟java程序进行互动，在java程序中会写一些sql语句。

 

 

2.

提醒你不能重复

如果有黄色钥匙 代表有组件 

 第二种添加

 

新增

 在项目开发中推荐使用将全部列名写出
数据表中字段名列表顺序可以与表中不一致，但是values后面必须一对一对应

删除数据

 where子句(条件)用于筛选满足特定的添加的数据进行删除 修改和查询

 

 一个百分号代表任意多个字符

一对一 在两张表呢主键相同，主键关联

一对多 多个学生可以属于一个班级，一个班级也可以对应多个学生

 

多对多，多对多一定有中间表，

主外键类型必须一样，一般主外键一般是int，FK开头，主键和外键全部大写        

 

 

jdbc

第一步关联 现在已经关联成功

这个地方会报一个错，sql异常 直接try catch抛出就行

在ResultSet有很多方法，getSteing getboolean getInt

根据数据类型去get 

如果报这个错需要在url添加一句 

不建议在没有服务器身份验证的情况下建立SSL连接。 根据MySQL 5.5.45 +，5.6.26 +和5.7.6+的要求，如果未设置显式选项，则默认情况下必须建立SSL连接。 为了与不使用SSL的现有应用程序兼容，将verifyServerCertificate属性设置为’false’。 您需要通过设置useSSL = false显式禁用SSL，或者设置useSSL = true并提供信任库以进行服务器证书验证。

这个报错信息比较容易理解，我们直接在MySQL的url连接中添加一个参数useSSL=false，即可解决该报错问题。
 

创建一个Lib文件，把mysql jar放进去

一定要添加到项目里面， 如果不把这个搞进项目里面，项目就连接不上了

finally语法:

try{
可能包含异常的代码

}catch(异常类 变量名){
异常处理代码

}…(多个catch)

finally{
后置处理代码

}

优化

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

//工具类
public class JDBCUtil {
    //静态成员变量，静态不需要去new对象
    static String url = "jdbc:mysql://localhost:3306/students?useSSL=false";
    static String name="root";
    static String pwd = "123456";
    //为什么这个地方用private，本身这个地方就不让你调，如果想调把公共拿走
    private static void closeRs(ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                rs=null;
            }
        }
    }
    private static void closeSt(Statement st){
        if(st!=null){
            try {
                st.close();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                st=null;
            }
        }
    }
    //私有化 为什么要私有化，因为不让别的东西调用他
    private static void closeConn(Connection conn){
        if(conn!=null){
            try {
                conn.close();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                conn=null;
            }
        }
    }

    //公共方法
    public static void release(Connection conn,Statement st,ResultSet rs){
        closeRs(rs);
        closeSt(st);
        closeConn(conn);
    }

    public static  Connection getConn(){
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url,name,pwd);
            //   DriverManager.getConnection("jdbc:mysql://localhost:3306/students?useSSL=false","root","123456");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

}