Java基础4-面向对象概述;super();this()

昨日内容回顾

1. java基本数据类型:

   • byte : 一个字节,-128 ~ 127 = 256

   • short : 两个字节, -32768 ~ 32767

   • int : 四个字节,

   • long : 八个字节,

   • float : 4字节

   • double : 8字节

   • boolean : 1个字节

   • char : 2个字节

2. 运算符

   • 算数: (+号) (-号) + - * / % (+号) (-号) a++ ++a b-- --b
   • 赋值: = += -= *= /= %=

3. 布尔表达式的逻辑运算符

   • | : 单或，没有短路情况。
   • & : 单与,同上。
   • ^ : 异或，a == b->false a !=b -> true
   • ! : 取反
   • && : a && b ,a == false ,b 不运算，短路了。
   • || : a || b ,a == true , b 不运算，短路了。

4. java中数字的表现形式

   • 十进制 int x = 100 ;
   • 八进制 int y = 077 ;
   • 十六进制 int z = 0xef;

5. 将一个byte数变换成00-FF之间的一个字符串
   
   [思路]:
   
   1）将b和十六进制数0x0F做&运算取得低四位的值。
   
   2）再将b右移4位，再次和0x0F做&运算取得高四位的值。
   
   3）构造字符数组，按下标取得对应的字符即可。

作业解答

1. 定义一个函数，函数功能是动态提取int[]中元素的最大值

    public int maxArr(int[] arr){
        if(arr==null || arr.length=0){
            System.out.println("非法数组");
            return -1;
        }
        max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
   

2. 定义一个函数，从数组中查询指定的元素首次出现的位置

    public int findIndex(int[] arr, int x){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==x){
                return i;
            }
        }
        if(i==arr.length)
            return -1;
    }
   

3. 定义函数，完成冒泡排序，大数下沉

    // 5 4 3 2 1
    // 4 3 2 1 5
    // 3 2 1 4 5
    // 2 1 3 4 5
    // 1 2 3 4 5
    public void bubbleSort(int[] arr){
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(arr[j]>=arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
   

4. 折半查找

    public int halfFind(int[] arr, int x){
    // 2 4 6 8 9 10 23 32 34 45 ---> 8
        int min = 0;
        int max = arr.length-1;
   
        while(min<=max){
            int index = (min+max)/2;
            if(arr[index]==x){
                return index;
            }
            else if(arr[index]>x){
                max = index-1;
            }
            else{
                min = index+1;
            }
        }
        return -1;
    }
   

5. 定义一个函数，实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。

    public void transArr(int[][] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<=i;j++){
                int tmp = arr[i][j];
                arr[i][j] = arr[j][i];
                arr[j][i] = tmp;
            }
        }
    }
   

6. 遍历三维组数，横向输出三维数组的每一个层。

    public void out3DArr(int[][][] arr,boolean flag) {
        if(flag==true) {
    	    for(int i = 0;i<arr.length;i++) {
    		    for(int j=0;j<arr[i].length;j++) {
    			    for(int k=0;k<arr[i][j].length;k++ ) {
    				    System.out.print(arr[i][j][k]+"\t");
    			    }
    			    System.out.println();
    		    }
    		    System.out.println("--------------------------------------");
    	    }
        }
        else {
    	    for(int i =0;i<arr.length;i++) {
    		    for(int j=0;j<arr.length;j++) {
    			    for(int k=0;k<arr.length;k++) {
    				    System.out.print(arr[j][i][k]+"\t");
    			    }
    			    System.out.print("\t");
    		    }
    		    System.out.println();
    	    }
        }
    }
   

7. 定义一个类:Dog 有名称 color age cry();

    public class Dog {
        private String color;
        private int age;
   
        public void cry() {
            System.out.println("汪汪汪...");
        }
    }
   

8. 阐述出来堆区，栈区，何时出现溢出，如何解决。

   1）堆内存：存放对象，当构造大量对象时，会出现堆溢出，可以通过java -Xmx设置最大堆内存大小， java -Xms设置初始堆内存大小
   
   2）栈内存：方法栈，当方法无限递归调用时出现，通过java -Xss 设置栈内存大小

9. 将一个字节转换成0~255之间的整数：将符号位作为数字位

    public int byte2Int(byte b){
        return b&0xff;
    }
   

10. 对数组进行冒泡排序（实现倒序），封装成方法，返回排序后的数组

    // 1 2 3 4 5
    // 2 3 4 5 1
    // 3 4 5 2 1
    // 4 5 3 2 1
    // 5 4 3 2 1
    public void bubbleSort(int[] arr){
        for(int i=arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                if(arr[j]<=arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }
    

11. 实现数组的拷贝，将一个数组中的元素复制到另一个数组中，如果元素个数不等，或者截取，或者回绕。

    public void copyArr(int[] srcArr, int[] destArr) {
        if(srcArr.length>=destArr.length) {
    	    for(int i = 0;i<destArr.length;i++) {
    		    destArr[i] = srcArr[i];
    	    }
        }
        else {
    	    for(int i = 0;i<destArr.length;i++) {
    		    destArr[i] = srcArr[i%srcArr.length];
    	    }
        }
    }
    

12. 输出整数的二进制表示方式

    public void int2bit(int x){
        System.out.print("0x");
        for(int i=31;i>=0;i--) {
    	    System.out.print(((a>>i)& 0x1));
        }
    }
    

13. 选择排序

    public void selectSort(int[] arr) {
        // 5 4 3 2 1
        // 1 5 4 3 2
        // 1 2 5 4 3
        // 1 2 3 5 4
        // 1 2 3 4 5
        for(int i = 0;i<arr.length-1;i++) {
            for(int j=i+1;j<arr.length;j++) {
                if(arr[i]>=arr[j]) {
                    int tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }
    

OOP

Oriented object program，面向对象编程

1. entity：实体，new：新建

2. 面向对象的特征：

   • 封装
   • 继承
   • 多态

3. 对象：
   
   切实存在的个体

4. 类：

   • 物以类聚，人以群分。人找人，虾找虾。
   • 对现实事物的软件抽象

5. 类的成员：

   • 成员变量：属性,数值类型的基本数据类型默认值是0，与声明顺序无关.存放在对象所在的堆内存中

   • 成员函数：方法

   • 构造函数

   • 构造代码块

   • 定义方式:

       class 类名 //首字符大写，$_开头
     

6. 堆：数组和对象在堆中

7. 栈：方法在栈中，StackOverflow

8. 局部变量：定义在方法或语句中，没有默认初始化值，必须初始化，存放在栈中，所在范围结束后，空间自动释放

9. 单位换算
   
   1024 = 1k
   
   2^10 = 1024
   
   1kb = 1024 byte
   
   1mb = 1024k byte
   
   1gb = 1024m byte
   
   1tb = 1024g byte
   
   1pb = 1024t byte
   
   1eb = 1024pb
   
   1zb = 1024eb
   
   1yb = 1024zb
   
   1nb = 1024yb

java VM调整堆大小：

1. 堆默认是1/4物理内存，栈空间默认是1m

2. java -X //查看java非标准输出帮助

3. java -Xmx100m //设置jvm的堆空间最大值

4. java -Xms100m //设置jvm的堆空间初始值

5. java -Xss100m //设置jvm的栈空间最大值

6. 查看java进程id使用jps

7. 查看指定java进程的堆内存信息使用：jmap -heap pid

java匿名对象

//匿名对象1
new Person().run();
//匿名对象2，作为参数进行传递
run0(new Person());

封装

将部分成员隐藏起来，外界只能通过其他方式进行访问。一般

使用private进行修饰，保证安全性

• public -- private

构造函数

1. 函数名和类名相同

2. 没有返回值：创建后肯定返回的是该类的对象

3. 如果类没有定义构造函数，jvm分配一个空构造。如果类定义了构造函数，没有空构造

4. 可以重载

5. 创建对象
   
   new Person();

构造代码块

1. 创建对象时调用

2. 构造函数之前

对象创建过程

1. 构造代码块：从上到下按序执行

2. 构造函数

3. 成员变量

   • color = null ;

   • color = "black";

   • 构造代码块

   • 构造函数

静态代码块

1. 在类加载期间执行，而且只执行一次

2. 类的信息存放在方法区，jvm中还有堆区(heap)，栈区(stack)

3. 静态成员之间可以互相访问，按序执行。

4. 静态成员不可以访问非静态成员。

5. 非静态成员可以访问静态成员

6. 静态成员通过类访问，和对象无关(类名.静态成员)

OOA

Oriented object analyze，面向对象分析

OOD

Oriented object design，面向对象设计

一切都是对象

面向过程的：c语言

javabean，标准java类

pojo：plain old java object,

class Dog{
    private String color;
    public String getColor(){
        return color;
    }
    public void setColor(String c){
        color = c;
    }
}

this

指向对象自身的引用，类似于成员变量，使用private进行修饰

1. 静态方法不可以使用this

2. this.：访问成员变量

3. this()：访问当前类的构造函数,对this的调用必须是第一条语句。为了构造函数的重用

继承

1. extends

2. 只支持单重继承，不支持多重继承

3. 支持多层继承

super()

1. 访问超类的构造函数

2. 必须是第一行代码

3. 构造函数的第一行代码要么是this(),要么是super(),默认是super()

4. super.xxx 访问超类的成员

函数的覆盖

1. 重写，overwrite

2. 只有在继承的情况下

3. private方法不可以被覆盖

4. 成员变量：不可以被覆盖

练习

1. Car{String color,int tires}

    class Car{
        private String color;
        private int tires = 4;
        public void setColor(String color){
            this.color = color;
        }
        public String getColor(){
            return color;
        }
    }
   

2. 百钱买百鸡

   • 公鸡：5/只
   • 母鸡：3/只
   • 小鸡：1/3只
   • 100买100只鸡

class BuyChick{
    public static void main(String[] args){
        for(int i=0;i<=100/5;i++){
            for(int j=0;j<=100/3;j++){
                for(int k =0;k<=100*3;k=k+3){
                    int money = i*5+j*1+(k/3);
                    int count = i+j+k;
                    if(money==100 && count==100){
                        System.out.println("公鸡："+i+"，母鸡："+j+"，小鸡："+k);
                    }
                }
            }
        }
    }
}

作业

1. 将按位运算操作，尤其是左移和右移(有无符号)整理到自己的博客中。
   
   重点说明清晰负数的运算过程。

2. byte数到十六进制字符串表现形式程序设计原理和实现方式整理到博客中。

3. 定义函数，计算一位整型数组所有元素的和。