JAVA深入

1.冒泡排序
2.类的调用 方法调用 变量调用
3.String应用
4.StringBuffer应用
5.this和super应用
6.对象Integer应用
7.封装




1.冒泡排序：
public class Test {


public static void main(String[] args) {
//冒泡排序
int[] a = new int[]{21,31,12,323,211,324,212,65};  //定义数组
int x;
for (int i = 0; i < a.length - 1; i++) {           //第一层循环  每个数字最多比较次数为a.length - 1  
for(int j = 0; j < a.length - 1 - i; j++){     //第二层循环，每比较完一个数字 下一个数字的比较次数 - 1
while(a[j] > a[j + 1]){                   //当下一个数小于前面的数字时  交换
x = a[j];
a[j] = a[j + 1];
a[j + 1] = x;
}
}
}
for(int y :a){                             //遍历数组并将数组的元素依次赋值给 y
System.out.println(y);                 //输出y的值  注意： 输出语句在for循环语句中
}

}


}




2.类的调用 方法调用 变量调用


public class Test {


public static void main(String[] args) {
Test1 in = new Test1();
Test1 inr = new Test1(100000);    //实例化的同时
int a1 = in.a;            //调用变量a
int b1 = in.b;            //调用变量b  注意 此时b的值是在方法外部定义的值   如果没有赋初始值，那么b的值为0
in.getNumber(100);       //调用带参数的自定义方法
in.getnumber();         //调用不带参数的自定义方法
System.out.println(a1);
System.out.println(b1);
}
}




public class Test1 {
    public Test1(){
    System.out.println("这是被调用的构造方法");   //定义构造方法   返回值为空
    }
    public Test1(int a){
    this.a = a;
    System.out.println("这是重载的构造方法" + this.a + "\t" +a);  //重载构造方法  参数为a 赋值给全局变量a 
    }
int a = 3;
int b = 1;
public void getNumber(int a){         //定义带有参数的自定义方法
this.b = a;                      //将参数传递给全局变量b
System.out.println(b);
System.out.println(this.a);
System.out.println(a);            
}
public void getnumber(){             //自定义方法重载
System.out.println("这是方法的重载");
}

}






3.String的应用


public class Test {


public static void main(String[] args) {
String a = "adsfdsgafdd";
String b = "adsfdsgafdd";
System.out.println(a.indexOf("a"));  //从左向右检索第一次出现字符a的位置  注意：字符串位置是从0开始数
System.out.println(a.lastIndexOf("s"));//从右向左检索第一次出现字符s的位置  注意：检索后输出的是字符s在字符串中的位置 不是从右向左数第几个
System.out.println(a.charAt(3));     //检索字符串中第四个字符
System.out.println(a.equals(b));     //比较两个字符串  注意：当a是用new定义时  两个字符串的比较只能用equals不能用==
System.out.println(a.substring(3));  //截取从第4到最后的所有字符
System.out.println(a.substring(2,4)); //截取从第三到第五包含第二不包含第五的字符
System.out.println(a.substring(1,a.length())); //截取从第二到最后的字符
System.out.println(a.replace("a", "p")); //用p替换字符串中的a 
}
}


输出结果
0
5
f
true
fdsgafdd
sf
dsfdsgafdd
pdsfdsgpfdd




4.StringBuffer应用


public class Test {


public static void main(String[] args) {
StringBuffer a = new StringBuffer();   //实例化
String b = "1,2,3,4,5,6";
String[] c = b.split(",");            //String的应用split  将字符串按照特定符号分割成多个元素并赋值给数组   当字符串中没有这个符号时
                                    //数组长度为1
for (int i = 0; i < c.length; i++) {
a.append(":" + c[i]);         //将数组的每个元素前面加上：然后组装成字符串并赋值给a  a此时的类型是StringBuffer类型
}
a.delete(0, 1);                 //删除字符串中从0到1包含0不包含1的字符  即删除字符串a的第一个字符   这个应用十分重要要会灵活应用
System.out.println(a);          
String e = String.valueOf(a);   //将a从StringBuffer类型转换成String类型并赋值给String类型的e
System.out.println(e);
a.reverse();                  //倒转字符串a  不是很重要
System.out.println(a);
}
}




5.this和super的应用
子类：
public class Test2 extends Test1 {
        String school;
        int number;
        public Test2(){
        super();
        System.out.println("调用了父类的默认构造方法");
        System.out.println("这是子类默认的构造方法");
        }
        public Test2(int a){
        super();
        System.out.println("调用了父类默认构造方法  注意 该语句一定要在子类方法里的第一行 父类 默认构造方法只能在子类的构造方法中调用 自定义方法不可调用");
        System.out.print("在子类构造方法里使用super调用父类的方法message ");
        super.message();
        this.number = a;
        this.age = a + 1;
        System.out.println("进行带参数的实例化时将自动调用该构造函数 " + "\t" + "子类的带参数的构造函数被调用了！");
        System.out.println("这是子类带参数的构造方法    ");
        System.out.println("在该方法中可以使用this调用父类的变量");
        System.out.println("从父类继承的变量age此时的值是" + age);
        System.out.println("子类自定义变量number的值是" + number);
        }
        public void useMessage(){
        System.out.print("在子类自定义方法中调用父类带参数的自定义方法message");
        super.message(18, "张三");
        System.out.println("这是子类的自定义方法");
       
        }
        public void useMessage(int a , String b){
        System.out.println("这是子类自定义方法的重载");
        this.number = a;
        this.school = b;
        System.out.println("姓名" + this.name + "学号" + number + "学校" + school + "年龄" + age);
        }
        }






父类：
public class Test1 {
  int age;                    //定义父类的成员变量
  String name;
  
public Test1(){               //定义父类默认的构造方法
System.out.println("这是父类的无返回值的构造方法");
}
public Test1(int a){          //定义父类带参数的构造方法  构造方法将在实例化的时候自动调用  
System.out.println("这是父类的有返回值得构造方法  形参类型是int型");
   this.age = a;
   System.out.println("带参数实例化时将参数传递给age" + age);
   System.out.println("这时形参a的值是："+ a);
}
  
   public void message(){         //定义父类自定义方法
  System.out.println("这是父类的自定义方法");
   }
   public void message(int a,String n){   //重载父类自定义方法  
  this.age = a;
  this.name = n;
  System.out.println("这是父类自定义方法的重载   形参有两个 一个int类型  一个 String 类型");
  System.out.println("调用该方法的时候需要提供两个参数  int类型的参数传递给age，String类型的参数传递给name" + age + "\t"+ name);
   }
}




测试类：


public class Test {


public static void main(String[] args) {
    Test2 a1 = new Test2();
    System.out.println("-----------------------------分隔符1-------------------------------------");
    Test2 a2 = new Test2(10086);
    System.out.println("-----------------------------分隔符2-------------------------------------");
    int y = a1.age;
    String x = a1.name;
    int n = a2.number;
    String m = a2.school;
    a1.message();
    System.out.println("-----------------------------分隔符3-------------------------------------");
    a1.message(110, "老舍");
    System.out.println("-----------------------------分隔符4-------------------------------------");
    a1.useMessage();
    System.out.println("-----------------------------分隔符5-------------------------------------");
    a1.useMessage(120, "山东轻工业学院");
}
}


运行结果：
这是父类的无返回值的构造方法
调用了父类的默认构造方法
这是子类默认的构造方法
-----------------------------分隔符1-------------------------------------
这是父类的无返回值的构造方法
调用了父类默认构造方法  注意 该语句一定要在子类方法里的第一行 父类 默认构造方法只能在子类的构造方法中调用 自定义方法不可调用
在子类构造方法里使用super调用父类的方法message 这是父类的自定义方法
进行带参数的实例化时将自动调用该构造函数 子类的带参数的构造函数被调用了！
这是子类带参数的构造方法    
在该方法中可以使用this调用父类的变量
从父类继承的变量age此时的值是10087
子类自定义变量number的值是10086
-----------------------------分隔符2-------------------------------------
这是父类的自定义方法
-----------------------------分隔符3-------------------------------------
这是父类自定义方法的重载   形参有两个 一个int类型  一个 String 类型
调用该方法的时候需要提供两个参数  int类型的参数传递给age，String类型的参数传递给name110 老舍
-----------------------------分隔符4-------------------------------------
在子类自定义方法中调用父类带参数的自定义方法message这是父类自定义方法的重载   形参有两个 一个int类型  一个 String 类型
调用该方法的时候需要提供两个参数  int类型的参数传递给age，String类型的参数传递给name18 张三
这是子类的自定义方法
-----------------------------分隔符5-------------------------------------
这是子类自定义方法的重载
姓名张三学号120学校山东轻工业学院年龄18




6.对象Integer 应用
public class TestInterger {
public static void main(String[] args) {
String s = "123456";
int y = Integer.parseInt(s);
System.out.println(y);
}
}




7.封装


封装类：
public class TestFz {


private String name;  //定义私有变量
private int age;
public String getName() {          //set  get
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void message(){                  //自定义方法
System.out.println("这是自定义方法");
this.name = "张三";
this.age = 12;
System.out.println("这是在方法里调用本类的私有变量");
System.out.println("姓名  " + name + "年龄  " + age);   //这时 name = 张三  age = 12
}
}


调用类：
public class TestFzhuang {
public static void main(String[] args) {
TestFz a = new TestFz();  //实例化
a.message();     //调用类方法
a.setAge(100);   //age赋值
a.setName("李四");  //name赋值
String name = a.getName();  //调用变量name并赋值给新类的自定义变量 name  这个name值是张三
int age = a.getAge();       //调用变量age并赋值给心累的自定义变量age  这个age值是12  新类的自定义变量名可随意取


System.out.println(name);  //这个name值是李四
System.out.println(age);   //这个age值是100
}
}
输出结果：
这是自定义方法
这是在方法里调用本类的私有变量
姓名  张三年龄  12
李四
100
 


注意 在调用类中如果set语句放在get语句下面  那么输出语句的的结果是 张三 12