JavaSE面向对象-笔记

数组

1、数组的特点

1.其长度是确定的，数组一旦被创建，它的大小就是不可改变的
2.其元素必须相同类型，不允许出现混合类型
3.数组中的元素可以是任何数据类型，包括基本类型和引用类型
4.数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量
  数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

2、创建数组

创建数组格式：
    数据类型[] 数组名 = new 数据类型[数组长度];
静态化初始数组：初始化数组时就已经每个数组赋值
    int [] a = {1,2,3,4,5};	//静态化初始数组
	Man [] mans = {new Man(),new Man()};//静态初始化数组，可存储任意类型包括类
动态化初始数组：初始化数组时，定义好了数组的大小（初始化后数组大小不可变化）
    int [] a = new int [5];	//创建大小为5的数组
	int num=1;
	for(int i=0;i<a.length;i++){	//使用for循环对a数组进行赋值
        a[i]=num;	//每次循环给数组a赋值
        num++;
    }

3、数组边界

数组下标合法区间：[0,length-1]，如果越界就会出现异常
	public static void main(String [] args){
    	int[] a = new int [2];	//数组长度为2
    	System.out.println(a[2]);	//异常，因为a[2]相当于数组中的第3个值
	}
ArrayIndexOutOfBoundsException:数组下标越界异常，常出现的异常类型

4、数组的使用

foreach循环：主要用于遍历数组和集合
    public static void main(String [] args){
    	int[] arrs = {1,2,3,4,5};
    	for(int array : arrs){	//foreach遍历数组
            System.out.print(array+"\t");
        }
	}
数组也可以作为形参传入，方法的返回值类型也可以是数组

5、多维数组

静态创建多维数组：
    int[][] arr = {{1,2},{2,3}};	//二维数组
	for(int[] each : arr){	//使用foreach遍历二维数组
        for(int i : each){
        	System.out.print(i+"\t");
        }
         System.out.println(); 
    }
动态创建多维数组：
   	int[][] arr2 = new int[2][2];	//创建一个二维数组
	for(int i=0;i<arr.length;i++){	//for循环赋值
        for(int j=0;i<arr[i].length;j++){
            arr2[i][j] = i;
        }
    }

6、Arrays类

Arrays常用类使用：
    public static void main(String[] args) {
        //copyOfRange数组复制   copyOfRange(源数组,开始下标，结束下标);
        int[][] a = {{1,2},{3,4}};
        int[][] b = Arrays.copyOfRange(a,0,1);
        for (int[] i : b){
            for (int j : i){
                System.out.println(j);
            }
        }

        //equals数组值队比是否相同
        int[] a1 = {1,2,3,4};
        int[] b1 = {1,2,3,4};
        System.out.println(Arrays.equals(a1,b1));   //equals：true

        //binarySearch指定范围搜索特定值 Arrays.binarySearch(查找的数组,开始值，结束值，查找的key);
        int[] a2 = {1,2,3,4,33,6,3};
        int i = Arrays.binarySearch(a2, 0,5,2);
        System.out.println(i);

        //sort数组排序
        int[] a3 = {1,3,2,534,634,72};
        Arrays.sort(a3);    //对数组进行排序
        System.out.println(Arrays.toString(a3));

        //fill数组填充 Arrays.fill(填充的数组,开始值，结束值，填充的key);
        int[] a4 = new int[5];
        Arrays.fill(a4,1,5,6);
        a4[0] = 1;
        System.out.println(Arrays.toString(a4));
    }

面向对象

1、类与方法

1.对象是类的实例化，类就是对象的抽象。
2.类的组成:属性(成员变量)、方法、构造方法(用于创建对象)
    public class Dog(){
        String name;	//属性
        
        //修饰符 类名([形参]){}
        public Dog(){
            System.out.println("无参构造方法");
        }
        public void eat(){
            System.out.println("方法");
        }
    }
3.this和super关键字：this是指当前对象，super指父类
    public class Animal{
        String name = "动物";
    }
	class Dog{
        String name = "小狗";
        public void getName(){
            System.out.println(this.name);	//小狗
            System.out.println(super.name);	//动物
        }
        public static void main(String[] args{
            Dog dog = new Dog();
            dog.getName();
        }                  
    }
4.staic关键字：
	变量：static修饰的变量为静态变量，是所有对象共享的变量
    方法：静态方法属于类，不属于对象，静态方法只可以调用静态变量
    代码块：类加载完后是最早加载的
5.final关键字：
    变量：final修饰的变量为常量，初始化后不可再更改
    方法：final修饰的方法不可被继承
                          

2、三大特性

封装：属性私有，get/set方法。高内聚，低耦合
	用处：1.提高程序的安全性，保护数据
    	 2.隐藏代码实现细节
    	 3.统一接口
    	 4.增加系统可维护性
    public class Test{
        private String name;
        
        public String getName(){	//get方法
            return name;
        }
        public void setName(String name){ //set方法
            this.name = name;
        }
        
    }
继承：使用extends继承父类，子类继承父类的所有非私有的方法和属性
    1.重写：父类和子类同时拥有此方法时，就是方法的重写
    2.在未指定父类时，所有的类的父类都是Object类
   	public class Animal{
        String name;
        public void eat(){
            System.out.println("动物吃东西！");
        }
        public void walk(){
            System.out.println("动物行走");
        }
    }
	class Dog extends Animal{
        public void walk(){		// 子类重写父类的walk()方法
            System.out.println("狗行走");
        }
        public static void main(String[] args){
            Dog dog = new Dog();
            dog.name = "大黄";	//子类继承父类的属性
            dog.eat();	//子类继承父类的方法
            dog.walk();	//子类重写父类的方法，优先调用子类重写的方法
        }
    }
多态：一种定义，多种实现
    1.实现多态必须满足继承关系、方法重写、父类的引用子类的实例： Person s = new Student();
	2.可以调用没有重写的父类方法，重写方法时调用子类的方法，不可以调用子类特有的方法。
    Public class Person{
        public void eat(){
            System.out.println("人类吃东西");
        }
        public void sleep(){
            System.out.println("人类睡觉");
        }
    }
	class Student extends Person{
        public void eat(){		//重写eat()方法
            System.out.println("学生吃东西");
        }
        public void walk(){		//子类特有方法
            System.out.println("学生走路");
        }
        public static void main(String[] args){
            Person s = new Student();
            s.eat();	//调用子类重写方法
            s.sleep();	//调用父类的方法
            s.walk();	//错误！不可以调用子类特有的方法
        }
    }
    

3、抽象类与接口

1.抽象类:
	abstract修饰的类和方法为抽象类、抽象方法，抽线类的抽象方法必须由子类进行实现。
    抽象类可以写抽象方法和非抽象方法。
    public abstract class Animal{	//抽象类
        public abstract void eat();	//抽象方法，由子类实现即可
    }
	class Dog extends Animal{
        public void eat(){
            System.out.println("狗吃东西");	//实现父类的抽象方法
        }
    }
2.接口：
    与抽象类的的区别：接口可以实现多继承，接口只可以写抽象方法，不能写实现。
    实现类必须重写抽象方法。
    public interface UserService{	//interface修饰的为接口
    	void add(String name);		//接口的方法为抽象方法，不可以实现
    	void delete(String name);
    	void update(String name);
    	void query(String name);
	}
	public class Test implements{	//implements继承接口
        public void add(String name){}	//实现接口的抽象方法
        public void delete(String name){}
        public void update(String name){}
        public void query(String name){}
    }