本文共 7784 字，大约阅读时间需要 25 分钟。

1 数组工具类Arrays

1.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。【值1，值2】

1.2 Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。

对引用类型数组，使用优化后的合并排序算法。 创建day05工程 创建cn.tedu.arrays包 创建Test1_Arrays.java

package cn.tedu.arrays; import java.util.Arrays; //这个类用来测试数组的工具栏Arrayspublic class Test1_Arrays {
        public static void main(String[] args) {
          method();//sort()    }       //sort()对数组里的数据进行排序    public static void method() {
          //1、创建静态无序的数组       int[] a = {
   96, 41, 78, 79, 15};             //2、对数组排序(快速排序，冒泡排序，希尔排序，合并排序......)       //对a数组进行排序,a数组是int类型是基本类型，底层是用的是优化后的快速排序算法       Arrays.sort(a);             //3、打印数组里的数据       //[15, 41, 78, 79, 96]       System.out.println(Arrays.toString(a));    }      }

1.3 Arrays.copyOf(原数组，新的长度)

把数组复制成一个指定长度的新数组。

新数组长度大于原数组，相当于复制，并增加位置 新数组长度小于原数组，相当于截取前一部分数据

package cn.tedu.arrays; import java.util.Arrays; //这个类用来测试数组的工具栏Arrayspublic class Test1_Arrays {
        public static void main(String[] args) {
   //     method();//sort()       method2();//copyOf()    }       //copyOf()数组的复制    private static void method2() {
          //1、创建原数组       int[] a = {
   96, 41, 78, 79, 15};             //2、复制数组       //copyOf(m,n) -- m是原数组的名称 n是新数组的长度       //如果新数组的长度  >  原数组的长度 --  扩容/相当于新增位置       int[] newa = Arrays.copyOf(a, 10);        //如果新数组的长度  <  原数组的长度 --  缩容/相当于截取       int[] newb = Arrays.copyOf(a, 3);             //3、打印新数组的数据       //[96, 41, 78, 79, 15]       System.out.println(Arrays.toString(a));//老数组的数据和长度都不变       //[96, 41, 78, 79, 15, 0, 0, 0, 0, 0]       System.out.println(Arrays.toString(newa));//改变的是新数组       //[96, 41, 78]       System.out.println(Arrays.toString(newb));    }     //sort()对数组里的数据进行排序    public static void method() {
          //1、创建静态无序的数组       int[] a = {
   96, 41, 78, 79, 15};             //2、对数组排序(快速排序，冒泡排序，希尔排序，合并排序......)       //对a数组进行排序,a数组是int类型是基本类型，底层是用的是优化后的快速排序算法       Arrays.sort(a);             //3、打印数组里的数据       //[15, 41, 78, 79, 96]       System.out.println(Arrays.toString(a));    }            }

2 变量

2.1 概念

可以改变的数，称为变量。

一般通过三部分来描述一个变量。 变量类型， 变量名， 变量值。 其中三部分都是可以改变的，根据需要来确定即可。 变量的使用原则：就近原则。尽量控制到最小范围。

2.2 局部变量

定义在方法里，或者局部代码块中。

注意： 必须手动初始化，来分配内存。 如：int i=5; 或者 int i; i=5;

作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

2.3 成员变量

定义在类里，方法外。

注意： 不用初始化，也会自动被初始化成默认值。

作用域是整个类中，类消失了，变量才释放。

八大基本类型都有各自的默认值。 引用类型的默认值都是null。

2.4 测试

package cn.tedu.variable; import org.junit.Test; //这个类用来测试变量的使用public class Test2_Variable {
      //成员变量：在类里方法外 +  不需要手动初始化，会自动初始化  + 作用范围在整个类里    int sum;    int count = 20;       //单元测试Junit方法    //要求：@Test注解 + public + void + 无参    //测试效果：选中方法名 -- 右键 -- Run as -- Junit test    @Test    public void show() {
          //局部变量：在方法里 + 必须手动完成初始化 + 作用范围在方法里       int count = 10 ;             //当成员变量名和局部变量名相同时，变量的使用有就近原则       System.out.println(count);//10，使用了附近的count       System.out.println(sum);//0    } }

3 面向对象

3.1 概念

《Thinking in java》 – 老师？推荐？的书

所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）

3.2 三大特征

1、 封装性，把相关的数据封装成一个“类”组件

2、 继承性，是子类自动共享父类属性和方法，这是类之间的一种关系 3、 多态，增强软件的灵活性和重用性

4 类和对象

4.1 类

1、 Java语言最基本单位就是类，类似于类型。

2、 类是一类事物的抽象。 3、 可以理解为模板或者设计图纸。

4.2 对象

每个对象具有三个特点：对象的状态，对象的行为和对象的标识。

1、 对象的状态用来描述对象的基本特征。

2、 对象的行为用来描述对象的功能。

3、 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。

4、 类是一类事物的抽象，对象是具体的实现。

汽车类：

实现可以有奥迪汽车对象、有宝马汽车对象。

4.3 类和对象的关系

1、 计算机语言是用来描述现实世界事物的。成员属性+成员方法

2、那怎么通过java语言描述呢？通过类来描述事物，把事物的特征当做类的成员变量，把事物的行为当做类成员方法。

分析手机事物：

特征：颜色，尺寸，品牌，价格。。。

功能：打电话，发短信，听音乐。。。。

类：手机类，抽取相同的特征和功能

对象：可以按照模板生产很多个手机，比如1号手机对象，包含特有的成员变量和成员方法

5 类和对象的创建和使用

类用关键字class来创建

对象使用关键字new来创建 /new Scanner() / new Random()/ new int[]; /

5.1 练习1：类的创建使用

package cn.tedu.oop; //这个类用来测试类和对象的创建和使用//一个.java文件中可以存在多个class，只能有一个被public修饰的，//.java的文件名要和被public 修饰的一致public class Test3_OOP{
       public static void main(String[] args) {
          //测试：产生人类对象       //通过new创建对象，p是引用类型的变量，引用了Person对象的地址值       Person p = new Person();             //调用p的功能       p.eat();       p.study();       //调用p的属性        System.out.println(p.country);//null       System.out.println(p.age);//0       System.out.println(p.name);//null    }} //通过class定义类，用来描述人类：抽象的规定人这一类事物的特征和功能class Person{
       //特征   -- 成员变量/成员属性    String country ;    int age;    String name;       //功能   -- 成员方法    //修饰符 返回值 方法名(参数列表){ 方法体 }    public void eat() {
          System.out.println("正在吃猪肉...");    }       public void study() {
          System.out.println("正在敲代码...");    }   }

5.2 对象在内存中的存储

Java把内存分成5大区域，我们重点关注栈和堆。

1、 一般来讲局部变量存在栈中，方法执行完毕内存就被释放

2、 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放

3、 每个堆内存的元素都有地址值

4、 对象中的属性都是有默认值的

5.3 单一对象内存图

5.4 练习2：创建多个对象

package cn.tedu.oop; //这个类用来测试类和对象的创建和使用//一个.java文件中可以存在多个class，只能有一个被public修饰的，//.java的文件名要和被public 修饰的一致public class Test5_OOP3{
          public static void main(String[] args) {
                 //测试              Animal a1 = new Animal();              //给属性赋值              a1.name="大黄";              a1.age=3;              //调用功能              a1.eat();              System.out.println(a1.name);//null---大黄              System.out.println(a1.age);//0---3                                        Animal a2 = new Animal();              //给属性赋值              a2.name="小黑";              a2.age=4;              //调用功能              a2.eat();              System.out.println(a2.name);//null---小黑              System.out.println(a2.age);//0---4                                 }} //通过class定义类，用来描述动物：抽象的规定动物一类事物的特征和功能class Animal{
          //特征       String name;       int age;             //功能       public void eat() {
                 System.out.println("吃啥都行");       }      }

5.5 多个对象内存图

6 封装

6.1 概述

封装是指隐藏对象的属性和实现细节

仅仅对外提供公共的访问方式。

好处：

1、 提高安全性

2、 提高重用性

3、 可以封装类可以封装方法封装属性

6.2 private关键字

是一个权限修饰符，用于修饰成员变量和成员函数/方法。

被私有化的成员只能在本类中访问。

6.3 练习1:封装学生

创建学生类，创建学生对象测试

package cn.tedu.oop;//这个类用来测试封装public class Test6_Private {
          public static void main(String[] args) {
                 //测试              Student s= new Student();                           //设置值//           s.name="韩梅梅"; //因为name属性被private修饰了，外界看不到没法赋值              s.setName("韩梅梅123");//设置值              s.gender=0; //0表示女1表示男                           //调用              s.coding();//           System.out.println(s.name);//因为name属性被private修饰了，外界看不到没法直接访问              System.out.println(s.getName());//获取值              System.out.println(s.gender);       }}//创建学生类class Student{
          //特征--成员属性       private String name;             //提供公共的访问方式setXxx()，用来设置属性的值       public void setName(String n) {
                 name=n; //给成员属性赋值       }       //提供公共的访问方式getXxx()，用来获取属性的值       public  String getName() {
                 return name;//返回name属性的值       }             //TODO 封装以下属性并提供公共的setXxx()/getXxx()       //TODO 测试属性的赋值和获取方式       int gender;       String addr;       byte age;       int snum;       String subject;                         //功能--成员方法       //通过private关键字实现封装，只能本类访问，相对安全       public void coding() {
                 System.out.println("正在敲代码...");       }}

7 拓展：

7.1 数组的扩容与缩容方式

7.2 了解其他算法

如：合并算法，二分算法，快速算法等，冒泡最常见，也是面试中出现率最高的

7.3 创建Teacher类，并创建Teacher对象测试

老师事物：设置特性和功能特征：姓名、年龄、住址功能：讲课 测试：创建Teacher对象调用老师的属性和功能修改老师的属性 package cn.tedu.oop; //这个类用来测试类和对象的创建和使用//一个.java文件中可以存在多个class，只能有一个被public修饰的，//.java的文件名要和被public 修饰的一致public class Test4_OOP2{
       public static void main(String[] args) {
   //     创建Teacher对象       Teacher t =  new Teacher();      //     修改老师的属性       t.addr="北京";       t.age=18;       t.name="蔡徐坤";      //     调用老师的属性和功能       t.teach();       System.out.println(t.addr);       System.out.println(t.age);       System.out.println(t.name);          }} //通过class定义类，用来描述老师：抽象的规定老师一类事物的特征和功能class Teacher{
   //  特征：姓名、年龄、住址    String name;    int age;    String addr;   //  功能：讲课    public void teach() {
          System.out.println("正在讲java基础");    }   }

转载地址：https://lawsssscat.blog.csdn.net/article/details/102940572 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！