java基本概念

大家好，欢迎来到IT知识分享网。

基本概念

变量、基本类型及运算符

什么是变量

驼峰命名法
骆驼式命名法的命名规则可视为一种惯例，并无绝对与强制，为的是增加识别和可读性。

成员变量与局部变量

8种基本类型 栈内存储
整数类型：byte、 short、 int、 long
浮点类型：float、double
字符类型：char
布尔类型：boolean
switch-case语句可以判断byte、short、char、int类型的变量；在JDK7.0以后可以判断String类型的变量

基本数据类型的使用方法： 1.基本类型转换：小类型到大类型是自动完成的 2.运算时运算结果自动升级（升级为默认类型或者当前最高类型） 3.从大类型到小类型强制转换需要强制转换符，但会造成精度损失或溢出 

引用数据类型 堆内存储
字符串 String ；数组 Array ；类 class ；接口 interface

运算符

类别	详细
算数运算符	++ – 取余（%） < > >= =（赋值）==（判断） -1%5=-1；1%-5=1； byte b =5; b=b+5; //编译通不过（先求和再赋值） b+=5；//编译通过（只进行一次运算）
逻辑运算符	|   &   ||   &&   ！(用于boolean类型的表达式) ‘|’、’&’–>两边都运算    ‘||’、’&&’–>短路
比较运算符	== != < <= > >= instanceof(检查是否是类的对象) 结果是boolean类型 例：  ‘hello’ instanceof String结果为true
位运算符	<<:左移   >>:右移   (最高位补什么由原有数据的最高位而定) >>>:无符号右移(无论最高位是什么，右移后最高位补0)
三目运算符	（ ？：）又称条件运算符,可嵌套使用

语法结构、方法、数组

方法：实现某个功能、可重复使用的代码块
程序=算法+数据结构   软件=程序+数据

数组的定义

面向对象

基本概念

面向对象设计原则：

• 找出应用中可能需求变化的代码，把他们独立出来。不要和那些不需要变化的代码混在一起
• 针对接口编程，而不要针对实现类编程
• 多用组合，少用继承
• 为了交互对象之间的松耦合设计而努力
• 类应该对扩展开放，对修改关闭
• 依赖倒置，不要依赖抽象，不要依赖具体类

//构造方法举例： public class StuInfo { 
    String name; int id; public StuInfo(String name,int id,int age){ 
    this.name=name; this.id=id; } } 

类与对象

• 对象：现实世界中存在的实体。属性（静态特征）和方法（动态行为）
• 区分一个对象：属性值不同
• 类是具有相同属性和方法的一组对象的集合
• 现实世界：对象–>类 ===》 虚拟世界：类–>对象
• 类是对象的数据类型；类规定对象所具有的属性或方法
• 创建对象：

this关键字
  指代当前对象的引用，在实例内部指向当前对象

java三大特性

一、封装

• 封装 ：{ }
• if{}: 封装一个条件结构   for(){}: 封装了一个循环结构
• 类封装了一组对象所具有的属性和方法
• 类是一组具有相同属性和方法的对象的抽象

1. 数据的封装
    私有化实例属性；提供公共的方法：set–get方法；在set方法中可以添加逻辑语句
   
2. 封装的好处
    1.隐藏具体实现 2.保护数据 3.代码重用
   

二、继承（提高代码的复用性）

 //一个类继承另一个类：（关键词：extence） //语法: 访问修饰符 class 类名 extends 类名{} public class One { 
    public void show(){ 
    System.out.println("这是ONE的方法！"); } } public class Two extends One{ 
   } 上述代码，表示 Two 继承One Two可以使用One中属性和方法 (注意其修饰符) One 是父类、基类； Two 是子类、派生类 在JAVA中，一个类直能继承一个父类，《单一继承》；但可以多重继承 《所有类的基类：Object》 

子类如何继承父类的属性和方法：不是复制父类的属性和方法，而是在子类的实例内部有一个父类实例的引用（在创建子类对象的同时，创建了父类对象）

创建顺序：先父后子：1.先调用子类的构造方法；2.再执行子类构造方法的第一行代码前，调用父类的构造方法；3.调用完父类的构造方法后，回到子类构造方法中执行子类构造方法中的代码

super关键字：在子类实例内部指向父类实例的引用

• 在子类的构造方法中调用父类的构造方法：super(参数)
• super():写在子类构造方法的第一行代码的位置
• 如果调用父类的无参构造方法，可省略super()
• 注意：当父类中只有带参构造方法是，一定要在子类的构造方法中显式的调用父类有参构造方法

提取父类
  编写代码时，先父后子
 先有对象 –> 把具有相同属性和方法的一组对象抽象出类
 把具有大量相同属性和方法的多个类 抽象父类
任何具有大量相同属性和方法的多个类都可以抽象出父类? —>(不能)
 当子类与父类是is a的关系的时候，才能抽取父类
 子类和父类的关系: 子类 is a 父类
类与类之间的关系： is a   has a   use a

  手机，小米手机，用户（打电话 ），手机电池

•  在继承关系：子类重写父类的方法；
•  方法名相同、参数相同；
•  返回值类型相同，或者子类的返回值类型是父类返回值类型的子类类型；
•  修饰符的访问范围大于或等于父类方法的修饰符；
•  子类调用方法时，调用重写后的方法；
•  注意：如果子类中的方法签名和父类中的方法签名不同时不能构成方法的重写，而是重载（子类方法与继承自父类的方法的重载）
•  验证子类是否重写方法的正确：在子类重写方法的上面加上@Override

三、多态

1.多态的前提

• 封装
   父类和子类分别封装类的不变化部分和可变化部分
  
• 继承
   方法的重写（指的是实例方法，静态方法不可被重写->“覆盖”）
  

2.多态的格式
  父类的引用,指向子类的实例
3.使用多态
  父类引用类型的形参，子类实例类型的实参（多用）
  父类类型的数组，子类实例的元素
  父类类型的返回值类型，return子类实例
4.面向对象思想
修改关闭，扩展开放 –》开闭原则 –》好处：易维护、易拓展、代码复用
封装、继承（方法重写）、多态（功能拓展）

三个修饰符 static、final、abstract

static：

static使用：

• 静态属性：当类的所有对象共同使用一个属性时
• 静态方法：当类的方法中不操作任何一个实例属性时：Math
• 使用static修饰的静态代码块不能使用this和static关键词
• 示例：
  
  
  
  

final

接口

//定义接口的语法： public interface Fly { 
   } 接口中包含的内容: 1.公共的静态常量: [public static final] 类型 名称=value; 在接口中定义的常量默认是公共静态常量，不写[public static final]也是静态常量 2.公共的抽象方法： [public abstract] 返回值类型 方法名(参数列表); 其中[public abstract]不写也是公共抽象方法 ~~JDK1.8之后添加的：~~ 默认方法：default 返回值类型 方法名（参数列表）{ 
   } 类方法：static返回值类型 方法名（参数列表）{ 
   } 3.特点： a.接口不能实例化; b.类（实现类）实现接口中的方法; c.接口类型的引用可指向实现类的实例：多态的体现 d.接口之间也可以继承(extends)（可以多继承） 格式：interface 接口名 extends 接口1，接口2{ 
   } e.Java类之间是单一继承，但类可以实现多个接口 f.类同时继承其他类与实现接口：先继承后实现 格式：class 类名 extends 父类implements 接口名{ 
   } 

内部类

一、类可以包括：（成员变量、方法；静态变量、方法；局部变量）
二、内部类：在类的内部定义的类，包含以下四种

成员内部类、静态内部类、局部内部类、匿名内部类(特殊的局部内部类) 

三、成员内部类
  在 外部类之内 使用（注：不能在外部类的静态方法中使用）

  在 外部类外面 使用

  成员内部类调用 外部类 的方法

  内部类可访问（实例变量、方法），当与外部类变量同名时：

四、静态内部类

• 静态内部类可以有静态成员与非静态成员
• 静态内部类的静态方法能访问静态属性，不能访问所有的非静态属性
• 注：静态内部类中无论方法静态 or 非静态，都不能调用外部类的非静态属性：外部类的非静态属性需要创建外部类对象才能调用的，而静态内部类是不需要外部类对象就可以得到的。静态内部类中：静态方法不需要创建对象就可以调用的，而非静态方法是需要对象才能调用的。
  
  

//使用类名定义静态内部类，就像调用静态方法一样 OuterClass.InnerStaticClass ins=new OuterClass.InnerStaticClass(); ins.prt(); //通过导包调用静态内部类 import test01.OuterClass.InnerStaticClass; InnerStaticClass ins=new InnerStaticClass(); ins.prt(); 

五、局部内部类（定义在方法中的类）

六、匿名内部类

匿名内部类的使用:

• 当局部内部类继承自某个父类，或者实现某个接口
• 在方法中只使用一次
• 使用外部类的成员与局部内部类相同

//---------------实现某个接口的匿名内部类：--------------- //--定义接口 interface Indemo(){ 
    public void prt(); } //--通过匿名内部类实现接口 new InDemo(){ 
    @Override public void prt(){ 
    System.out.println("这是匿名内部类实现的接口"); } } //---------------继承自抽象父类的匿名内部类：--------------- //--定义抽象类 abstract class AbClass{ 
    public abstract void prt1(); public void prt2(){ 
    System.out.println("抽象父类中的非抽象方法"); } } //--通过匿名内部类实现抽象类中的方法 class ab = AbClass(){ 
    @Override public void prt1(){ 
    System.out.println("匿名内部类，实现抽象类中的抽象方法"); } } 

集合

异常

• 所有的异常类是从 java.lang.Exception 类继承的子类。
• Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。
• Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。
• Error 用来指示运行时环境发生的错误。例如，JVM 内存溢出。一般地，程序不会从错误中恢复。
• 异常类有两个主要的子类：IOException 类和 RuntimeException 类。

IO流

反射

• Class ：是一个类
• class ：定义类的关键词

//----------------类对象与类的对象-------------------- //类的对象：创建了一个Student类的对象s Student s=new Student(); //类对象创建了一个Class类的对象c,指代某个类对象 Class c=null; //--------------------得到类对象的三种方法：-------------------- // 1.通过类的对象得到 Student s=new Student();//创建Student的对象，存放的是对象的属性方法等信息 Class c = s.getClass();//创建了一个Class的对象，对象指的是Student类，存放Student类的信息 // 2.通过类名创建类对象 Class c = Student.class;//通过类名创建Student类对象 // 3.通过类的位置 创建类对象 Class c = Class.forName("java.lang.String"); 

线程

创建线程的方法：继承Thread类;实现Runnable接口 //-------------继承Thread类------------- public class ThreadOne extends Thread(){ 
    @Override public void run(){ 
    System.out.println("继承Thread类"); } } //创建对象，启动线程 ThreadOne one = new ThreadOne(); one.start(); //-------------实现Runnable接口------------- public class RunnableOne implements Runnable(){ 
    @Override public void run(){ 
    System.out.println("实现Runnable接口"); } } //把继承Runnable接口的类对象，传递给Thread类对象；然后调用Thread类的start方法 RunnableOne one = new RunnableOne(); Thread th = new Thread(one); th.start(); 

线程的状态

• 正常状态：
    初始状态：创建线程对象，但没有启动线程
    可运行状态：start()方法，没有运行run方法
    运行状态：运行run方法
    终止状态：run方法运行结束
  
  
  
  
  
  
• 阻塞状态
  
  sleep(): 哪个对象调用，哪个对象睡眠 –》 进行阻塞状态
  join():哪个对象调用，哪个对象先执行 –》 当前线程阻塞
  
  
  

多个线程，操作同一对象的数据，数据产生不一致 –》数据并发

• 多个线程 多任务
• 同一数据 临界资源
• 破坏了操作的原子性
• 线程异步：两个人一起走 速度快 ，数据不安全
  解决数据并发问题：线程同步 （两个人，一个一个走 速度慢，数据安全）
  

线程同步的实现方式

线程之间的通信：生产者与消费者的关系
Account对象与上面相同

• 取钱线程
  
  
• 存钱线程
  
  

网络服务

一、创建服务器端

1. 步骤

• 创建serverSocket对象（并绑定端口）
• 调用accept()方法，等待来自客户端的连接
• 调用getInputStream/getOutputStream方法，进行I/O
• 关闭socket

2. 示例代码
   
   

二、创建客户端

1. 步骤

• 创建Socket对象
• 获取输入/输出流对象
• 关闭

2. 示例代码