Java的面向对象部分概念

JAVA的部分概念

1.变量

• 声明：int a //声明一个整形变量，名为a
• 初始化：第一次赋值
  int a= 250; //声明整型变量并赋值为250
• 使用：
  1）对变量的操作是对它所存的那个数的操作
  int a = 5;
  int b = a+10;
  System.out.println(b) 输出b的值是15 不加引号，是变量
  System.out.println(“b”) 输出b
  2) 变量的使用必须与数据类型匹配
  int a =3.14; //编译错误
  3）变量在用之前必须声明并初始化
• 命名
  1）只能包含字母，数字，下划线或$，不以数字开头
  2）严格区分大小写
  3）不能使用关键字
  4）可以中文命名，但不建议
• 驼峰命名法：第一个字母小写，其他大写。

2.基本数据类型

• int
  1）整型，4个字节
  2）整数相除，结果还是整数，小数舍弃
  3）整数运算时超出范围则溢出
  直接量超范围为编译错误
  运算时超范围为溢出
• long
  1）长整型，8个字节
  2）在数字后加L
  3）运算若有溢出，在第一个数字后加L
  4）存储时间 long time = System.currentTimeMillis();
  System.out.println(time);
• double
  1）浮点型，8字节
  2）float需在后面加f或F
  4）boolean：只赋值为ture或false
  5）char：特殊符号通过’'转义

3. 基本数据类型转换

byte short int long float double 从小到大排序

• 两种方式
  1）自动转换：从小到大
  2）被迫转换：从大到小
• 两点规则：整数直接量可直接给byte short char
  type short char 参与运算，先一律换为int

4.scanner接受输入

• 在package下 import java.ntil.Scanner;
• 在main下 Scanner scan = new Scanner(System.in);
• 在第二步之下 int age = scan nextInt();

满足条件就干事，不满足条件就不干事----if
满足条件就干事，不满足条件就干另一件事-----if else

5.循环结构

• while 三要素：
  1）循环变量的初始化
  2）循环条件（以循环变量为基础）
  3）循环变量的改变（向着循环的结束变化）
• do…while
  要素1与要素3相同时选do…while

6.for结构

• break：常与条件语句一块用，常在if句中 （跳出for） 只跳1层循环
• continue :跳出循环体中剩余语句进行下一次循环

循环问题
如果业务转换为“当…” 用while “直到…”用do…while 固定次数循环 用for

7.数组

• 是一种数据类型（引用类型）
• 相同数据类型元素的集合
• int[] a = new int[6];
• 数组初始化：
  1）int[] arr = new int[4];
  2）int[] arr = {3,5,7,9};
  3）int[] arr = new int[4]{3,4,5,7};
• 数组访问
  1）通过（数组名.length）获取数组长度
  2）通过下标访问数组元素
• 数组遍历：arr.length
• 数组的复制：
  System.arraycopy(源数组，下标，目标数组，下标，要复制的个数）；

import.java.util.Arrays;
int[] a1 = Arrays.copyOf(a,6); //a是源数组 6是目标数组的长度

• 数组扩容：(创建了一个新的数组，并将原数组复制过去)
  int[] a = {10,20,30,40};
  a = Arrays.copyOf(a,a.length+1);
• 数组排序：
  Arrays.sort(arr); //升序（从小到大）
  冒泡排序： 方法：
  步骤：5个数冒4轮
  每一轮都是从第一个元素开始冒，每一次都是和下一个元素比
  冒出来就不带他玩了
  如果要降序，则把>改为<即可

int arr = {6,7,8,9};
for(int i=0;i<arr.length-1;i++){    //控制轮
        for(int j=0;j<arr.length-1-i;j++) {    //控制次
          if(arr[j]>arr[j+1]){
               int t = arr[j];
               arr[j] = arr[j+1];
               arr[j+1] = t;}
       }
}            **4个数  3轮**

8.方法

五要素：修饰词，返回值类型，方法名，参数列表，方法体
public static int sum(int num1,int num2)
方法可有返回值，也可以没有(void)

• 方法完成后：
  1）若需要用到方法中的某个数据------有返回值
  2）若不需要用到方法中的某个数据------无返回值
• 有参数更加灵活：int a = Math.random(1,99);//表示范围是1-99
• 调方法：(无返回值) 在main函数中：方法名();
  案例：
  //方法的演示
  public class MethodDemo {
  public static void main(String[] args) { int b= plus(5,6);
  System.out.println(b);
  double a = getNum(); System.out.println(a);
  say();
  sayHi(“刘思斌”);//有参必须传参
  }
  //有参有返回值
  public static int plus(int num1,int num2)
  { int num = num1+num2;
  return num; }
  //无参有返回值
  public static double getNum()
  { return 88.88;//return后必须加值 } // 有参无返回值
  public static void sayHi(String name)
  { System.out.println(“大家好！我叫”+name+“,今年20岁了”); }
  //无参无返回值
  public static void say() { System.out.println(“大家好！来自山西农业大学”); } }

9.面向对象：

• 什么是类、对象：
  1）现实世界由很多对象组成，基于对象抽出了类
  2）对象：存在单个的个体
  类：类别/类型，一类个体
  3）类中包括：1.所有对象所共有的属性--------变量
  2 . 所有对象所共有的行为--------方法
  4）一个类可以创建多个对象。同一类型所创建的对象，结构相同，数据不同。
  5）类是对象模板，对象是类的案例
• 方法重载：
  1）发生在一个类中，方法名称相同，参数列表不同
  2）在编译时根据方法签名自动绑定调用的方法
• 构造方法
  1）给成员变量赋初值
  2）与类同名，没有返回值类型
  3）在创建对象时被自动调用
  4）若自己不写构造，则默认一个无参构造方法
  5）构造方法可以重载
  注：如果在构造方法中调用另一个构造方法，则this语句必须是第一条语句。

class student{
      String name;
      int age;
      String address;
     Student(String name1,int age1,String address1){
     name=name1;  age=age1;  address=address1;}
}


main(){
    student zs = new student("zhangsan"25"LF");
    }

• this: 只用在方法中，在方法中访问成员变量之前有个this（默认）
  指代当前对象：成员变量和局部变量同名，this不可省略
  注：this只能用在非static方法中，不能用在static方法中。
  this只能用在构造方法中

Random rand = new Random();
x = rand.nextInt(2);
括号是（2）  2是范围，可取值0-1

10.内存管理（由JVM管理）

1）堆：new出来的对象（成员变量）
2）栈：存储局部变量（方法变量）
3）方法区：存储.class字节码文件（方法）

• null：空。没有指向任何对象。若引用的值为null，则该引用不能再进行任何操作。若操作则发生NullPointerException空指针异常
• 引用类型之间画等号（写new的）
  1）指向同一个对象
  2）通过修改会影响另一个数据的访问
• 引用类型数组
  1）

Student[] stus = new Student[3];
stus[0] = new Student("zhangsan"25"LF");

2）

Student[] stus = new Student[]{
    new Student("zhangsan"25"LF"),
    new Student("zhangsan"),
    }

3）

int[][] arr = new int[3][];
  arr[0] = new int[2];
  arr[1] = new int[3];
  arr[1][0] = 100;

4）

int[][] arr = new int[3][4];
for(int i=0;i<arr.length;i++){
    for(int j=0;i<arr[i].length;j++){
        arr[i][j] = (int)(Math.random()*100);
        }
}

11.继承

1）作用：代码复用
2）通过extends继承
3）有传递性

12.super

指当前对象的超类对象

• super的用法：
  1）super.成员变量名----------访问超类的成员变量
  2）super.方法名（）-----------调用超类的方法
  3）super（） -----------调用超类的构造方法
  在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法。
  在派生类的构造方法中若调用了超类的构造方法，则不再默认提供。
  调儿子用this 调爹用super.
  超类：共有的 派生类：特有的。

13.向上造型

1）超类型的引用指向派生类的对象
2）能点出来什么，看引用的类型
儿子继承爹
爹指向儿子
爹不能用儿子

14.方法的重写（override）

1）发生在父子类中，方法名称相同，参数相同，方法体不同。
2）重写方法被调用时，看对象的类型new谁用谁，与向上造型相反
3）遵循两同两小一大
两同：方法名、参数列表相同

• 重写与重载的区别：
  1）重写：发生在父子类中，方法名称相同，参数列表相同，方法体不同
  2）重载：发生在一个类中，方法名称相同，参数列表不同，方法体不同

数据（变量）私有化（private），行为（方法）公开化（public)

15.修饰符

• 访问控制修饰符：
  1）public：公开的，任何类
  2）private：私有的，本类
  3）protected：受保护的，本类派生类同包类
• 说明：
  1）类的访问修饰符只能是public或默认
  2）类中成员的访问修饰符上面3种都可以

16.final

• 修饰变量：变量不改变
  修饰成员变量：(两种方式)
  1)声明的同时初始化
  2)在构造方法中初始化
  修饰局部变量，在用之前初始化即可。
• 修饰方法：方法不被重写
• 修饰类：类不能被继承

17.static(静态的）

• 静态变量：由static修饰，属于类的，通过类名点访问，所有对象共享数据（图片、音频）只有一份
• 静态方法：
  1）由static修饰
  2）类，存在方法区，一份
  3）用类名点访问
  4）静态方法无隐式this传递，不能访问实例成员
  5）方法的操作仅与参数相关而与对象无关
• 静态块：
  1）属于类的，在类被加载期间自动执行，类只加载一次
  2）何时用：常常用于加载/初始化静态资源（图片、音频）

18.static final常量

1）必须声明同时初始化
2）类名点访问，不能被改变
3）建议：常量名大写，多个单词用_分隔
4）编译器编译时将常量替换为值
5）何时用：数据永远不变且经常使用

19.设计规则

1）将派生类共有的属于和行为，抽到超类中-----抽共性
2）派生类行为都一样，设计为普通方法
派生类行为都不一样，设计为抽象方法
3）将部分派生类共有的行为，抽到接口中
符合既是也是原则时，使用接口

20.抽象方法

1）由abstract修饰
2）只有方法定义，没有具体的实现（连{}也没有）

• 抽象类：
  1）由abstract修饰
  2）包含抽象方法的类必须是抽象类，抽象类可以定义构造方法，构造方法可以有{}
  3）抽象类不能被实例化
  4）抽象类是需要被继承的，派生类重写抽象类中的抽象方法，重写后大部分用return结尾
  5）抽象类的意义
  1.封装共有属性和行为
  2.为所有派生类提供统一类型
  3.包含抽象方法，提供统一入口

21.成员内部类

1）类中套类，外面的为外部类（Outer），内部的（Inner）
2）内部类通常只有外部类中使用，对外不具备可见性
3）内部类在外部类中创建
4）内部类中直接用外部类成员，或私有的

22.匿名内部类

1）若建立一个类（派生类）的对象，且对象只一个，此时该类不命名，称匿名内部类
2）匿名内部类想访问外部变量，该变量是final的

23.接口(implement)

1）是一种数据类型
2）由interface定义
3）只包含常量和抽象方法
4）接口不能实例化
5）接口是需要实现，实现类：必须重写抽象方法
6）一个类可以实现多个接口，用逗号隔开
7）先继承后实现，接口继承接口
在main函数中要写的话，必须使用向上造型方可成功。
实现多继承

24.多态

• 意义：
  1）同一类型的引用指向不同的对象时，有不同的实现
  同一类型被造型为不同类型时，有不同的功能
• 向上造型
  1）超类型引用指向派生类的对象
  2）类型：超类、接口
  3）能点出什么，看引用的类型
• 强制类型的转换，成功的条件
  1)引用指向的对象，就是该类型
  2）引用指向的对象，实现了该接口或继承的该类

25.对象转换

对象转换：子类对象和父类对象在一定条件下相互转换
自动转换：子类对象自动转换为父类对象。
Partent = child; 爹在前，儿子在后
强制转换：父类对象强制转换为子类对象。

Employee emp = new Employee(“刘明”,30,5000);
System.out.println(emp);
Person p = emp;  //自动  爹前，儿子后
System.out.println(p);
p.sayHello();
emp = (Employee)p;  //强制  儿子前，爹后
emp.printState();

26.instanceof类型

v1 instanceof v2
如果v1是v2类型或父类型的实例，返回true 否则 false

例：Fruit是父类，Apple和Orange是子类
Fruit fruit = new Apple(); //属于方法重写 new谁用谁
Orange orange = new Orange();
表达式fruit instanceof Orange的结果是false。
表达式fruit instanceof Fruit的结果是true。
表达式orange instanceof Fruit的结果是true。
表达式orange instanceof Apple的结果是false。

27.异常处理

• Throwable,Errow和Exception
  JAVA异常结构中定义有Throwable类，Errow和Exception是其派生的两个子类。其中Exception表示由于网络故障，文件损坏等引起的异常。而Errow表示JAVA运行时环境出现的错误，例如：JVM内存资源耗尽等。

• try-catch
  1）try{…}语句中指定了一段代码，该段代码就是一次捕获并处理例外的范围。
  2）在执行过程中，该段代码可能会产生并抛出异常对象，它后面的catch语句对这些异常进行处理。
  3）如果没有异常产生，所以的catch代码都被略过不执行。
  4）在catch中声明的异常对象（catch(exception e)）。

try{
   String str = null ;
   System.out.println(str.length());
} catch (NullPointerExpectation e){
   System.out.println("出现了空指针");
}

注释：
1）try语句块中出错代码以下内容不执行
2）应当在最后一个catch处捕获Expectation
3）尽量避免一个未捕获异常导致程序中断

• finally块
  1）finally是异常处理机制的最后一块，可以直接跟在try之后或者最后一个catch之后。
  2）finally可以确保只要程序运行到try语句块中，无论是否抛出异常，finally中的代码必定执行。
• throw关键字
  当程序发生错误而无法处理的时候，会抛出对应的异常对象，若想要自行抛出异常，可以使用throw，并生成指定的异常对象后抛出。

public void setAge(int age){
if(age<0||age>100){
throw new RuntimeException("年龄不合法");
}
this.age = age;
}

• throws关键字
  程序中许多方法会出现异常，用throws来声明这个方法将会抛出异常。
• 自定义异常
  使用自定义异常时必须先创建一个类，并且这个类后面继承Exception。在里面写一个构造方法，再重写这个构造方法，里面使用super。再在主函数的try中使用throw抛出异常，再用catch接住。

28.进程与线程

• 线程用于在一个程序中需要同时完成多个任务的情况，在单一线程下可以完成，也可以多线程（更快）
• 线程是并发运行代码的
• 有两种创建线程的方式：
  1.继承Thread并重写run()方法，run方法中希望线程执行逻辑

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t1 = new MyThread1();
		Thread t2 = new MyThread2();
		
		//启动线程要调用start方法，而不是直接调用run方法。
		//当start方法调用完毕后，run方法很快会被线程自行调用。
		t1.start();
		t2.start();

	}
}

class MyThread1 extends Thread{
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("你是谁啊？");
		}
	}
}

class MyThread2 extends Thread{
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("我是查水表的");
		}
	}
}

2.实现Runnable接口，单独定义线程任务

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//实例化两个任务
		Runnable r1 = new MyRunnable1();
		Runnable r2 = new MyRunnable1();
		//创建两个线程并指派任务
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		
		t1.start();
		t2.start();
	}
}


class MyRunnable1 implements Runnable{
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("你是谁啊？");
		}
	}
}

class MyRunnable2 implements Runnable{
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("我是查水表的！");
		}
	}
}