Java基础总结----第二章Java面向对象

调用成员变量的调用：

在其他的成员方法中可以直接调用，不需要用对象调用，但是在main方法中，main方法是一个static修饰的静态特殊方法，所以你可以直接调用，需要创建对象来用.调用，同理成员方法也是这么一回事。。

TestCher liuxiang;
liuxiang=new TestCher();
//调用类中属性的形式为对象名。属性名
System.out.println(liuxiang.no);
//调用类中属性的形式为对象名，方法名
System.out.println(liuxiang.getNo());//在这之前封装了get，set 方法

//liuxiang和yaoming不是对象，是对象名，其中存储的是地址哦
//同一个类中所有用权限修饰符修饰的东西都可以被访问到

this关键字的作用：

1.this的第一种用法，在一个方法中，全局变量和局部变量同名时候，可以实际用this解决屏蔽问题，因为this表示对象，对象调用属性，所以直接调用全局变量。

2.this在成员方法中调用其他重载的其他方法。（方法重载在后面讲解）但是有限制，必须放在方法体的第一行，后面会讲解到super关键字，两个关键字不能在同一个方法内使用，因为都是要放在第一排的。。

public Father(int a,int b){
    this.a=a;
    this.b=b;
}  
public Father(int a,int b,int c){
        this(a,b);//要第一行
        this.c=c;
}
public Father (int a,int b,int c,int d){
        this(a,b,c);
        this.d=d;
}

3.

//主调方法:主动调用其他方法的方法成为主调方法；
// 被调方法 ：被其他方法调用的方法
public void doSomething(){
    method(this);
    System.out.println(this);
}
public void method(Father f){}

//method被调方法

public static void main(String[] args) {  
        Father father = new Father();  
        father.doSomething(); // 调用主调方法 doSomething  
    }  

方法重载：

方法重载在一个类中，如果两个方法名相同，参数不同一个方法成为另一个方法的重载方法
注意事项：在同一个类中；方法名相同；参数类型，个数，顺序一个不同

例如：

public void eat() {
    System.out.println("喝西北风");
}

public void eat(Chicken c) {
    System.out.println("吃鸡肉");
}

public void eat(Beef b) {
    System.out.println("吃牛肉");
}

public void eat(Chicken c, Beef b) {
    System.out.println("吃鸡肉和牛肉");
}

public void eat(Beef b, Chicken c) {
    System.out.println("吃牛肉和鸡肉");
}

public void eat(Beef b, Chicken c, Hamburg h) {
    System.out.println("吃鸡肉和牛肉再加一个汉堡");
}

同时构造方法也可以重载；

构造方法：

//构造方法的作用是给对象进行初始化的工作的，实质是给属性赋值
//属性又叫成员变量，全局变量，实例变量
int age;
//构造方法使用时注意事项
//1.方法名必须和类名相同
//2.方法没有返回值类型，不能使用返回值类型修饰包括void
//3.如果类中没有显式定义构造方法，则编译期会默认加一个无参构造方法，如果有显式定义的构造方法则编译器不会添加无参构造方法
public Teacher(int a){  a=10
    //初始化顺序是：默认初始化-》显示初始化-》构造方法初始化
    System.out.println(age);  0
    age=20;
    System.out.println(age);  20
}

public static void main(String[] args) {
    //构造方法不能通过对象名的形式调用，只能使用new 关键字调用，从而创建出对象
    Teacher t = new Teacher (10);
    System.out.println(t.age);  20
}

静态方法和静态变量：

静态变量：

//static可以修饰变量，修饰的变量成为静态变量，静态属性，类变量，存储在jvm的方法区中
public static  int no;
public int age;
public static double score=90;
//静态常量要在定义时候同时初始化，否则编译报错，静态变量和常量都是在初始化复制的，
//在main方法运行之前
public static final double PI=3.14;
public static void main(String[] args) {
    StaticTest01 st=new StaticTest01();
    //静态变量的调用形式为
    //类名。静态属性名（推荐使用）
    System.out.println(StaticTest01.no);
    //对象名。属性名
    System.out.println(st.no);
    //静态常量的调用形式也是两种
    //类名。静态属性名（推荐使用）
    System.out.println(StaticTest01.PI);
    //对象名。属性名
    System.out.println(st.PI);

静态方法：

static int age;
    int no;
    //非静态方法可以直接用静态方法和静态使用，也能直接调用非静态属性，非静态方法
    public void doSomething(){
        System.out.println(age);
        System.out.println(no);
        Method();
        Method2();
    }
    //静态方法中，不能调用非静态的属性和非静态方法，可以直接调用静态属性和静态方法
    public static void saySomething(){
        System.out.println(age);
        Method2();
        //如果在静态方法中调用非静态的成员，可以通过创建对象进行间接调用
        StaticTest02 s=new StaticTest02();
        s.Method();
        System.out.println(s.age);
    }
    public void Method(){}
    //静态方法的定义形式
    // 权限修饰符 static 返回值类型 方法名（【参数类型 参数名】）{方法体}
    public static void Method2(){}
    public static void main(String[] args) {
//静态方法的调用形式
// 类名。静态方法名
        StaticTest02.Method2();
// 类名。静态方法名
        StaticTest02 s=new StaticTest02();
        s.Method2();
    }

静态块：

//静态块用于给类进行初始化，实质是初始化类变量
static int a;
int no;
static final double PI;
static{
    //静态块中定义的变量只能使用默认的修饰符
    //public int d;
    a=10;
    PI=3.14;
    //静态块中不能调用非静态的成员
    //System.out.println(no);
    System.out.println("静态块");
}

（*）单例模式：懒汉式，饿汉式。

//懒汉式
public class Single {
    //在类的外部有且只有一个对象
    //构造方法私有化，因为构造方法公有化没法保证只有一个对象
    private Single(){

    }
    //那么外部获取数据只能通过静态的形式获取数据，类名的形式获取
    // 所有非静态的都获取不了，因为对象创建不了
    private static Single s=null;
    public static Single getSingle(){
        //不能定义成局部变量，因为局部变量方法调用完就销毁了
       // Single s=null;
       if (s==null) s=new Single();
        return s;
    }

饿汉式：

public class Singlen {
    private static Singlen s = new Singlen();

    private Singlen() {
    }

    public static Singlen getSingle() {
        return s;
    }
}

性能对比：

/**
 *          懒汉式         饿汉式
 * 效率       低             高     懒汉式每次都要进行比较，比较浪费时间，所以效率比饿汉式低
 * 内存       少             多    懒汉式只有在需要的时候才会创建出来，而饿汉式不换、管是否
 *                                 使用，在做开始的时候就会把对象创建出来，所以占用内存
 */

数组的应用：

//数组是一个引用类型的变量
    //[]表示的是数组类型，int表示的是数组中保存的数据是int类型的
    //创建对象的一种形式
    //先声明
    int []a;
    Student s[];
    //在初始化
    //创建一个长度为5的数组。也就是数组中可以保存5个数据，而且此时数组中的数据为5个0；
    a=new int [5];
    //创建一个长度为5的数组，数组中的元素为5个null
    s=new Student[5];
    //创建一个新的数组，给a赋值，之前的数组变成了垃圾，被回收了，现在这个数组的长度是有元素列表
    // 的个数确定的，而且数组中的值就是1，2，3，4，5
    a=new int []{1,2,3,4,5};
    Student s1=new Student();
    Student s2=new Student();
    Student s3=new Student();
    Student s4=new Student();
    Student s5=new Student();
    //创建一个新的数组，给s赋值，之前的数组变成了垃圾，被回收了，现在这个数组的长度是有元素列表
    // 的个数确定的，而且数组中的值就是s1，s2，s3，s4，s5
    s=new Student[]{s1,s2,s3,s4,s5};
    //声明的同时初始化
    //等号左侧的【】写在对象名的前面还是后面都可以，语法正确
    int b[]=new int [5];
    int c[]=new int []{1,2,3,4,5};
    int d[]={1,2,3,4,5};
}

一些数组中的常用方法：

int a[] = {1, 2, 3, 4, 5};
//获取数组的长度，数组创建成功，长度不可以改交
System.out.println(a.length);
//数组复制
//copyof第一个参数是源数组第二个参数是新数组的长度
int b[] = Arrays.copyOf(a, 10);
//第二个参数指的是开始的位置，索引所在的值要，
//第三个参数指的是结束的位置，索引所在的值不要
int[] c = Arrays.copyOfRange(a, 1, 4);
int[] d = new int[10];
//第一个参数是源数组，第二个参数是源数组中的起始位置，第三个参数是复制到的新数组的
//第四个参数是新数组中从那开始复制，第五个参数是复制多长
System.arraycopy(a, 1, d, 4, 3);
int[] e = new int[10];
//数据填充，让数组中的值变成同一一样的值
Arrays.fill(e, 5);
for (int i : e) {
    System.out.print(i + "");
}for each 语句可以遍历数组。。往后学比较重要，方便。。

int a[] = {9, 5, 1, 7, 3, 6, 4, 2, 8};
Arrays.sort(a);//升序排序
for (int i : a) {
    System.out.print(i + " ");
    System.out.println(Arrays.binarySearch(a, i));
}                 Arrays.binarySearch是一个查询元素在数组中的索引。第一个参数是一个排好序的数组，第二个是要找的元素。。采用的是二分法的寻找方法。时间复杂度O（logN）。返回的是元素的索引。

二维数组：

//二维数组
//先声明在初始化
int[][] a;
//创建一个二维数组，这个二维数组中可以存储三个一维数组，并且这三个一维数组的长度都为4
a = new int[3][4];
//创建一个二维数组，这个二维数组中有两个一维数组，数组的内容由元素列表赋值
a = new int[][]{{1, 2, 3, 4}, {4, 5}};
//给二维数组中的第一个一维数组初始化，初始化为长度为5的数组，且值都为0
a[0] = new int[5];
//声明的同时初始化
int[][] b = new int[3][4];
int[][] c = new int[][]{{1, 2, 3, 4}, {4, 5}};
//只有声明的同时初始化才有直接使用元素列表的形式赋值
int[][] d = {{1, 2, 3, 41}, {4, 51}, {7, 8, 9}};