java复习八百页从头开始——案例、截图、源代码

从零开始

简单java案例
- 面向对象基础篇
- - 面向对象高级篇

前提安装好idea和jdk

简单java案例

变量与数据类型、运算符表达式与语句、选择与循环、数组与方法使用

所有的一切从你好世界开始！！！

public class HelloWorld{
    public static void main(String args[]){
    System.out.println("Hello World");
    }
}

定义一个简单类

public class Helloabc {
    public static void main(String args[]){
        int num=10;
        num =30;
        System.out.println("num内容是："+num);
        System.out.println("num*num="+num*num);
    }
}

测试字符和整型字符之间转换

public class dome3 {
    public static void main(String[] args){
        char ch1 ='a';
        char ch2 =97;
        System.out.println("ch1="+ch1);
        System.out.println("ch2="+ch2
        );
    }
}

转义字符应用

public class dome4 {
    public static void main (String[]args){
        char ch1 ='"';
        char ch2 ='\';
        System.out.println("ch1="+ch1);
        System.out.println("ch2="+ch2);
        System.out.println(""Hello World"");
    }
}

浮点型（64个字节）数据计算

public class dome5 {
    public static void main(String[] args){
        float num =3.0f;
        System.out.println("两个小数相乘："+num*num);
    }
}

布尔类型（只有true和false)

public class dome6 {
    public static void main(String[] args){
        boolean flag =true;
        System.out.println("flag="+flag);
    }
}

数据类型转换
1>转换前后数据类型兼容
2>转换后的数据类型表示范围比转换前大
3>boolean类型只能存放true或false
4>一个整型常量和浮点型常量进行计算后结果为一个浮点型数据
5>两个int型常量计算结果为int型小数会被省略
6>任何类型数据都向String转型
7>单词首字母大写这一类属于引用数据类型

public class dome7 {
    public static void main (String[] args){
        int x=30;
        float y=22.19f;
        System.out.println("x/y="+(x/y));
        System.out.println("10/3.5="+(10/3.5));
        System.out.println("10/3="+(10/3));
    }
}

定义字符串变量

public class dome8 {
    public static void main(String[] args){
        String str="lixinghua";
        int x = 30;
        str= str + x;
        System.out.println("str="+str);
    }
}

数据类型强制转换

public class dome9 {
    public static void main(String[] args){
        float f=30.3f;
        int x=(int)f;
        System.out.println("x="+x);
        System.out.println("10/3="+((float)10/3));
    }
}

一元和算数运算符使用

%结果取余，符号与被除数相同

public class dome10 {
    public static void main(String[] args){
        boolean b =false;
        int x=10;
        int y=-30;
        System.out.println("b="+b+",!b="+!b);
        System.out.println("x="+x+",-x="+-x);
        System.out.println("y="+y+",+y="+ +y);//正号
        System.out.println(x+"+"+y+"="+(x+y));
        System.out.println(x+"-"+y+"="+(x-y));
        System.out.println(x+"*"+y+"="+(x*y));
        System.out.println(x+"/"+y+"="+(x/y));
        System.out.println(x+"%"+y+"="+(x%y));

    }
}

判断一个数是奇数还是偶数
用if分支判断语句，是否被2整除

public class dome11 {
    public static void main(String[] args){
        int num=10;
        if(num%2==0){
            System.out.println(num+"是偶数");
        }else{
            System.out.println(num+"是奇数");
        }
    }
}

关系运算符

自增自减

++a先加1再执行整个语句
a++先执行语句再将a的值加1

public class dome12 {
    public static void main(String[] args){
        int a=3,b=3;
        int x=6,y=6;
        System.out.println("a="+a);
        System.out.println(("t a++="+(a++)+",a="+a));
        System.out.println("b="+b);
        System.out.println("t ++b="+(++b)+",b="+b);
        System.out.println("x="+x);
        System.out.println("t x--="+(x--)+",x="+x);
        System.out.println("y="+y);
        System.out.println("t --y="+(--y)+",y="+y);
    }
}

逻辑运算

&&两真才真
||一真则真

括号运算符

先括号再乘除加减

位运算符

进行二进制位的运算

计算机没有定义负数表达形式，一般用补码，正数的原码、反码、补码都相同，负数的反码是除符号位为1外其他位全取反，补码就是“反码+1”

左移“<<“右移”>>"

运算符优先级

简洁表达式

选择与循环语句
顺序结构、选择结构、循环结构

上面例子都是顺序结构
选择结构：
if……else
判断奇数偶数

public class dome13 {
    public static void main(String[] args){
        int x=3;
        if(x%2==1){
            System.out.println("x是奇数");
        }else{
            System.out.println("x是偶数");
        }
    }
}

三目运算（？：）

public class dome14 {
    public static void main(String[] args){
        int max=0;
        int y=10;
        int x=3;
        max=x>y?x:y;
        System.out.println("最大值为："+max);
    }
}

switch语句

选择值只能是字符或是常量
符合case后面选择值执行至break，break跳出语句
不符合case则执行default所包含的语句
每一个case后面有一个break语句，不加会依次执行到最后
JDK1.7后可以直接利用String进行数据判断

public class dome15 {
    public static void main(String[] args) {
        int x = 3;
        int y = 6;
        char oper = '+';
        switch (oper) {
            case '+': {
                System.out.println("x+y=" + (x + y));
                break;
            }
            case '-': {
                System.out.println("x-y=" + (x - y));
                break;
            }
            case '*': {
                System.out.println("x*y=" + (x * y));
                break;
            }
            case '/': {
                System.out.println("x/y=" + (x / y));
                break;
            }
            default: {
                System.out.println("未知的操作");
                break;
            }
        }
    }
}

循环结构
while循环、do……while循环、for循环

while循环
如果出现死循环，按ctrl+c结束程序的执行
循环不确定次数确定循环结束条件的情况

public class dome16 {
    public static void main(String [] args){
        int x=1;
        int sum =0;
        while (x<=10){
            sum +=x;
            x++;
        }
        System.out.println("1~10累加结果为："+sum);
    }
}

do……while循环
至少执行一次

public class dome17 {
    public static void main(String [] args) {
        int x = 1;
        int sum = 0;
        do {
            sum += x;
            x++;
        } while (x <= 10);
        System.out.println("1~10累加结果为：" + sum);
    }
}

for循环
明确循环次数

public class dome18 {
    public static void main(String[] args){
        int sum=0;
        for(int x=1;x<=10;x++){
            sum +=x;
        }
        System.out.println("1~10累加结果为："+sum);
    }
}

循环嵌套打九九乘法表

public class dome19 {
    public static void main(String [] args){
        for(int i=1;i<=9;i++){
            for (int j=1;j<=i;j++){
                System.out.println(i+"*"+j+"="+(i*j)+"t");
            }
            System.out.println("n");
        }
    }
}

循环中断
break直接跳出循环
continue强迫程序跳到循环起始处，只是中断一次并没有跳出

数组与方法
一维数组、二维数组、多维数组

一维数组
声明：
数据类型数组名称[]=null;
数组名称 =new 数据类型[长度];
数据类型[] 数组名称=null；
数据类型数组名[]=new 数据类型[个数]
栈内存中保存的永远是数组的名称，只是开辟了栈内存空间数组是永远无法使用的

赋值并进行输出

public class dome20 {
    public static void main(String [] args){
        int score[] =null;
        score=new int[3];
        for (int x=0;x<3;x++){
            score[x] =x*2+1;
        }
        for (int x=0;x<3;x++){
            System.out.println("score["+x+"]="+score[x]);
        }
    }
}

静态初始化：
数据类型数组名[]={初值0，初值1，…,初值n}

求最大和最小值
数组名称.length -->返回一个Int型数据

public class dome21 {
    public static void main(String [] args){
        int score[]={67,89,87,100};
        int max=0;
        int min=0;
        max=min=score[0];
        for (int x=0;x
            if(score[x]>max){
                max = score[x];
            }
            if(score[x]
                min=score[x];
            }
        }
        System.out.println("最高成绩："+max);
        System.out.println("最低成绩："+min);
    }
}

整型数组小到大排序
冒泡排序

public class dome22 {
    public static void main(String [] args){
        int score[] ={67,89,87,69,90,100,75,90};
        for (int i=1;i
            for (int j=0;j
                if(score[i]
                    int temp=score[i];
                    score[i]=score[j];
                    score[j]=temp;
                }
            }
        }
        for (int i=0;i
            System.out.println(score[i]+"t");
        }
    }
}

改进版：
增加了循环输出，可观察到排序动态变化

public class dome23 {
    public static void main(String [] args){
        int score[]={67,89,87,69,100,75};
        for (int i=1;i
            for (int j=1;j
                if (score[i]
                    int temp=score[i];
                    score[i]=score[j];
                    score[j]=temp;

                }
            }
            System.out.println("第"+i+"次排序的结果：t");
            for (int j=0;j
                System.out.println(score[j]+"t");
            }
            System.out.println("");
        }
        System.out.println("最终排序结果：t");
        for (int i=0;i
            System.out.println(score[i]+"t");
        }
    }
}

二维数组
一维数组当做线性图形二维相当于一个表格
声明：
数据类型数组名[][];
数组名 =new 数据类型[行的个数][列的个数];

数据类型数组名[][]=new 数据类型[行的个数][列的个数]；
（声明score数组同时开辟一块内存空间）

定义及使用

public class dome24 {
    public static void main(String []args){
        int score[][]=new int[4][3];
        score[0][1]=30;
        score[1][0]=31;
        score[2][2]=32;
        score[3][1]=33;
        score[1][1]=30;
        for (int i=0;i
            for(int j=0;j
                System.out.println(score[i][j]+"t");
            }
            System.out.println("");
        }
    }
}

静态初始化

public class dome25 {
    public static void main(String []args){
        int score[][]={{67,61},{78,89,83},{99,100,98,66,95}};
        for(int i=0;i
            for(int j=0;j
                System.out.print(score[i][j]+"t");
            }
            System.out.println("");
        }
    }
}

区分两者
简单运行区别不大（本人喜欢直接输入idea推荐的那个，没做修改见谅，根据nt参数也能看出来吧哈哈哈）

例如九九乘法表格式看着不舒服可以将println改成print

多维数组
维数越高的数组其复杂程度也就越高

定义和使用

public class dome26 {
    public static void main(String []args){
        int score[][][]={{{5,1},{6,7}},{{9,4},{8,3}}};
        for (int i=0;i
            for (int j=0;j
                for (int k=0;k
                    System.out.println("score["+i+"]["+j+"]["+k+"]="+score[i][j][k]);
                }
            }
        }
    }
}

定义方法在主方法中调用
有的方法（method)称为（function)

public class dome27 {
    public static void main(String []args){
        A();
        A();
        A();
        System.out.println("hello");
    }
    //由main方法直接调用一定加上public static
    public static void A(){
        char c[]={'H','e','l','l','o',',','L','X','H'};
        for (int x=0;x
            System.out.print(c[x]);

        }
        System.out.println("");
    }
}

定义类时全部单词首字母必须大写，定义方法时第一个单词字母小写，之后每个单词的首字母大写，如A()改为printInfo()

有返回值方法的重载
System.out.println()方法也属于重载方法

public class dome28 {
    public static void main(String []args){
        int one=add(10,20);
        int two=add(10,20,30);
        float three=add(10.3f,13.3f);
        System.out.println("add(int x,int y)的计算结果："+one);
        System.out.println("add(int x,int y,int z)的计算结果："+two);
        System.out.println("add(float x,float y)的计算结果："+three);
    }

    private static int add(int x, int y) {
        int temp=0;
        temp=x+y;
        return temp;
    }
    private static int add(int x, int y,int z) {
        int temp=0;
        temp=x+y+z;
        return temp;
    }
    private static float add(float x,float y) {
        float temp=0;
        temp=x+y;
        return temp;
    }
}

递归调用
return中没有返回任何的内容，但执行了return语句后方法不再执行

public class dome29 {
    public static void main(String args[]){
        System.out.println("计算结果："+sum(100));
    }
    public static int sum(int num){
        if(num ==1){
            return 1;
        }else{
            return num+sum(num-1);
        }
    }

}

数组排序

public class dome30 {
    public static void main(String []args){
        int score[]={67,89,87,69,90,100,75,90};
        int age[]={31,30,18,17,8,9,1,39};
        sort(score);
        print(score);
        System.out.println("n---------");
        sort(age);
        print(age);
    }
    public static void sort(int temp[]){
        for (int i=1;i
            for (int j=1;j
                if(temp[i]
                    int x=temp[i];
                    temp[i]=temp[j];
                    temp[j]=x;
                }
            }
        }
    }
    public static void print(int temp[]){
        for(int i=0;i
            System.out.print(temp[i]+"t");
        }
    }
}

对于java本身也是有类库支持的，可直接使用"java.util.Arrays.sort(数组名称）"语句对数组进行排序
注意标点符号，一个错到处报错

数组复制
同上，可直接使用System.arraycopy()方法
copy()方法可自己尝试

public class dome31 {
    public static void main(String args[]){
        int i1[]={1,2,3,4,5,6,7,8,9};
        int i2[]={11,22,33,44,55,66,77,88,99};
        System.arraycopy(i1,3,i2,1,3);
        print(i2);

    }
    public static  void print(int temp[]){
        for (int i=0;i
            System.out.print(temp[i]+"t");
        }
    }
}

可变参数
向方法中传递可变参数之后，里面参数以数组形式保存下来
使用foreach输出

public class dome32 {
    public static void main(String []args){
        System.out.print("不传递参数 (fun()):");
        fun();
        System.out.print("n传递1个参数 （fun(1)）:");
        fun(1);
        System.out.print("n传递5个参数 （fun(1,2,3,4,5)）:");
        fun(1,2,3,4,5);
    }
    public static void fun(int...arg){
        for(int x:arg){
            System.out.print(x+"、");
        }
    }
}

面向对象基础篇

封装、继承、多态、抽象类与接口、异常与捕获及处理、包及访问控制权限

面向对象和面向过程

特性：封装性、继承性、多态性
类与对象：
类比喻为造汽车的设计图纸
对象则为造出来的汽车
类是由属性和方法组成
属性也可以称为变量
对象创建：
类名对象名称=null；
对象名称=new 类名（）；

类名对象名称=new 类名（）；

对象创建及使用

//定义person类
    class Person {
    String  name;
    int age;
    public void tell(){
        System.out.println("姓名："+name+",年龄："+age);
    }

}
public class dome33{
    public static void main(String args[]){
        Person per=null;
        per.name="张三";
        per.age=30;
        per.tell();

    }
}

出现报错：如果一个对象要被使用，则对象必须被实例化，未实例化的对象会出现异常

//定义person类
    class Person {
    String  name;
    int age;
    public void tell(){
        System.out.println("姓名："+name+",年龄："+age);
    }

}
public class dome33{
    public static void main(String args[]){
        Person per=null;
        per =new Person();//实例化per对象
        per.name="张三";
        per.age=30;
        per.tell();//per调用方法

    }
}

对象引用传递（看图好理解）

垃圾空间的释放：
没有形成任何的栈内存空间所引用，就形成了垃圾空间，等待垃圾收集机制进行回收，java本身提供垃圾收集机制，会不定期的释放不用的内存空间，只要对象不使用了就会等待GC释放空间
一个栈内存空间只能指向一个堆内存空间，如果要想再指向其他堆内存空间，则必须先断开已有的指向才能分配新的指向

封装性：
之对外不可见
eg.年龄为负不会报错，在入口出把关才可以避免，再开发中往往要将类中的属性封装（private)
格式：
private 属性类型属性名称；（属性）
private 方法返回值方法名称（参数列表）{}

属性为私有的不能由对象直接进行访问

class Person2{
    private String name;
    private int age;
    public void tell(){
        System.out.println("姓名："+getName()+",年龄："+getAge());
    }
    public String getName(){
        return name;
   }
   public void setName(String n){
        name =n;
   }
   public int getAge(){
        return age;
   }
   public void setAge(int a){
        if(a>=0&&a<150){           //此处加验证代码
            age=a;
        }
   }
}
public class domo34 {
    public static void main(String args[]){
        Person2 per=new Person2();
        per.setName("张三");         //调用setter设置姓名年龄
        per.setAge(-30);
        per.tell();
    }
}

声明一个构造方法

class Person3{
    public Person3(){
        System.out.println("一个新的Person3对象产生");
    }
}
public class dome35 {
    public static  void main(String args[]){
        System.out.println("声明对象：Person3 per=null;");
        Person3 per=null;                                 //声明不调用
        System.out.println("实例化对象：per=new Person3();");
        per=new Person3();                                //实例化对象时调用构造
    }
}

只要是类就必须存在构造方法，没有明确声明一个构造方法则编译时会直接生成一个无参数什么都不做的构造方法

通过构造方法为属性赋值

class Person4{
    private String name;
    private int age;
    public Person4(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public void tell(){
        System.out.println("姓名："+getName()+",年龄："+getAge());
    }
    public String getName(){
        return name;
    }
    public void setName(String n){
        name=n;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int a){
        if (a>=0&&a<150){
            age=a;
        }
    }
}
public class dome36 {
    public static void main(String args[]){
        Person4 per=new Person4("张三",30);
        per.tell();
    }
}

直接通过构造方法进行赋值，这比对对象实例化之后再单独调用setter方法更方便

构造方法重载

class Person5{
    private String name;
    private int age;
    public  Person5(){}
    public Person5(String name){
    this.setName(name);
    }
    public Person5(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public void tell(){
        System.out.println("姓名："+getName()+",年龄："+getAge());
    }
    public String getName(){
        return name;
    }
    public void setName(String n){
        name=n;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int a){
        if(a>=0&&a<150){
            age=a;
        }
    }
}
public class dome37 {
    public static void main(String args[]){
        Person5 per=new Person5("张三");
        per.tell();
    }
}

所有重载的方法按照参数个数由多到少或者由少到多排列

类设计分析
……

string的赋值与实例化

public class dome38 {
    public static void main(String []args){
        String name="小明";//直接赋值
        
        System.out.println("姓名："+name);
    }
}

**对于基本数据类型可以通过"=="进行内容比较（数值比较不等同地址及相同空间）**特殊方法public boolean equals(String str)

使用equals()方法对String的内容进行比较

public class dome39 {
    public static void main(String []args){
        String str1="hello";
        String str2=new String("hello");
        String str3=str2;
        System.out.println("str1 equals str2-->"+(str1.equals(str2)));
        System.out.println("str1 equals str3-->"+(str1.equals(str3)));
        System.out.println("str2 equals str3-->"+(str1.equals(str3)));

    }
}

使用new string()方式实例化String对象

public class dome40 {
    public static void main(String []args){
        String str=new String("hello");
    }

}

修改字符串内容

public class dome40 {
    public static void main(String []args){
        String str="hello";
        str=str+" world";//修改字符串
        System.out.println("str="+str);
    }

}

常用操作方法记下来

字符串与字符数组的转换
字符串可以使用toCharrArray()方法变成一个字符数组，也可以使用String类的构造方法把一个字符数组变成一个字符串

public class dome41 {
    public static void main(String []args){
        String str1="hello";
        char c[]=str1.toCharArray();
        for (int i=0;i
            System.out.print(c[i]+"t");
        }
        System.out.println("");
        String  str2=new String(c);
        String  str3=new String(c,0,3);
        System.out.println(str2);
        System.out.println(str3);
    }
}

取出字符串指定位置的字符

public class dome42 {
    public static void main(String[] args){
        String str1="hello";
        System.out.println(str1.charAt(3));//取第四个字符
    }
}

字符串与byte数组的转换
可以通过getBytes()方法将String变成一个byte数组，之后通过String的构造方法将一个字节数组重新变为字符串

public class dome43 {
    public static void main(String []args){
        String str1="hello";
        byte b[]=str1.getBytes();
        System.out.println(new String(b));
        System.out.println(new String(b,1,3));
    }
}

用length()方法取得字符串长度

public class dome44 {
    public static void main(String[] args){
        String str1="hello xiaoming";
        System.out.println("""+str1+""的长度为："+str1.length());
    }
}

数组操作中使用length取得数组长度没有（），字符串调用length()是一个方法，方法后面都有（）

String中使用indexOf()方法可以返回指定的字符串位置，如果不存在返回-1

String类对与判断字符串是否存在的方法提供有contains() (public boolean contains(String str)),此方法直接返回Boolean型数据，相对indexOf()方法更加简单一点

去掉左右空格（trim（）方法）

public class dome45 {
    public static void main(String []args){
        String str1="   hello   ";
        System.out.println(str1.trim());
    }
}

字符串截取

public class dome46 {
    public static void main(String []args){
        String str1="helloworld";
        System.out.println(str1.substring(6));//从第七个开始截取
        System.out.println(str1.substring(0,5));//截取0~5个
    }

}

按指定字符串拆分字符串

public class dome47 {
    public static void main(String []args){
        String str1="hello world";
        String s[]=str1.split("");//“""”按一个一个字符进行拆分“" "”按空格
        for (int i=0;i
            System.out.println(s[i]);
        }
    }
}

要避免正则表达式的影响，可以进行转义操作
eg.IP地址肯定想到根据“.”拆分，不能直接用点转义用“”

字符串的大小写转换

public class dome48 {
    public static void main(String []args){
        System.out.println("将"hello world"转写成大写："+"hello world".toUpperCase());
        System.out.println("将"HELLO WORLD"转成小写:"+"HELLO WORLD".toLowerCase());
    }
}

判断是否是指定字符串开头或结尾

public class dome49 {
    public static void main(String []args){
        String str1="**HELLO";
        String str2="HELLO**";
        if(str1.startsWith("**")){
            System.out.println("(**HELLO)以**开头");
        }
        if(str2.endsWith("*")){
            System.out.println("(HELLO**)以**结尾");
        }
    }
}

不区分大小写进行字符串比较

public class dome50 {
    public static void main(String []args){
        String str1="HELLO";
        String str2="hello";
        System.out.println(""HELLO"equals"hello""+str1.equals(str2));
        System.out.println(""HELLO"equalslgnoreCase"hello""+str1.equalsIgnoreCase(str2));
    }

}

指定字符串替换成其他字符串

public class dome51 {
    public static void main(String []args){
        String str="hello";
        String newStr=str.replaceAll("l","x");
        System.out.println("替换之后的结果："+newStr);
    }
}

引用传递

public class dome52 {
    public static void main(String []args){
        String str1="hello";
        System.out.println("fun()方法调用之前："+str1);
        fun(str1);
        System.out.println("fun()方法调用之后："+str1);
    }
    public static void fun(String str2){
        str2="MLDN";
    }
}

接受本类引用

class Dome {
    private int temp=30;
    public void fun(Dome d2){
        d2.temp=50;
    }
    public int getTemp(){
        return temp;
    }
    public void setTemp(int t){
        temp=t;
    }
}
public class dome52{
    public static void main(String []args){
        Dome d1=new Dome();//实例化
        d1.setTemp(50);//修改内容
        d1.fun(d1);//传回自己类
        System.out.println("temp="+d1.getTemp());
    }
}

范例

class Person{
    private String name;
    private int age;
    private Book book;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public String getName(){
        return name;
    }
    public void setName(String n){       //设置名字
        name=n;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int a){           //设置年龄
        age=a;
    }
    public Book getBook(){
        return book;
    }
    public void setBook(Book b){
        book=b;
    }
}
class Book{
    private String title;
    private double price;
    private Person person;
    public Book(String title,float price){
        this.setTitle(title);
        this.setPrice(price);
    }
    public String getTitle(){
        return title;
    }
    public void setTitle(String t){
        title=t;
    }
    public double getPrice(){
        return price;
    }
    public void setPrice(double p){
        price=p;
    }
    public  Person getPerson(){
        return person;
    }
    public void setPerson(Person person){

        this.person=person;
    }

}
public class dome53 {
    public static void main(String []args){
        Person per=new Person("张三",30);
        Book bk=new Book("JAVA SE 核心开发",90);
        per.setBook(bk);
        bk.setPerson(per);
        System.out.println("从人到书-->姓名："+per.getName()+";年龄："+per.getAge()+";书名："+per.getBook().getTitle()+";价格："+per.getBook().getPrice());
        System.out.println("从书找到人-->书名："+per.getBook().getTitle()+";价格："+per.getBook().getPrice()+";姓名："+per.getName()+";年龄："+per.getAge());
    }
}

扩展

this关键字
在本类构造方法中目的明确为属性赋值
明确标识两个属性“this.name"“this.age”

class Person7{
    private String name;
    private int age;
    public Person7(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getInfo(){             //取得信息
        return "姓名："+this.name+",年龄："+this.age;
    }
}
public class dome55 {
    public static void main(String []args){
        Person7 per1=new Person7("张三",33);
        System.out.println(per1.getInfo());
    }
}

this()只能放在构造方法的首行
对于this调用构造方法的时候一定要留一个构造方法做为出口

使用this调用本类的构造方法

class Person8{
    private String name;
    private int age;
    public Person8(){
        System.out.println("一个新的Person8对象被实例化");
    }
    public Person8(String name,int age){
        this();                 //调用Person类中无参构造方法
        this.name=name;
        this.age=age;
    }
    public  String getInfo(){
        return "姓名："+name+",年龄："+age;
    }
}
public class dome56 {
    public static void main(String []args){
        Person8 per1=new Person8("张三",33);
        System.out.println(per1.getInfo());
    }
}

观察this表示当前对象

class Person9{
    public String getInfo(){
        System.out.println("Person类-->"+this);
        return null;
    }
}
public class dome57 {
    public static void main(String[] args){
        Person9 per1=new Person9();
        Person9 per2=new Person9();
        System.out.println("MAIN方法-->"+per1);
        per1.getInfo();
        System.out.println("-------------");
        System.out.println("MAIN方法-->"+per2);
        per2.getInfo();
    }
}

比较对象

public class dome58 {
    public static void main(String []args){
        Person per1=new Person("张三",30);
        Person per2=new Person("张三",30);
        if(per1.getName().equals(per2.getName())
        &&per1.getAge()==per2.getAge()){
            System.out.println("两个对象相等");
        }else{
            System.out.println("两个对象不相等");
        }
    }
}

修改

static关键字
使用static声明城市属性

使用static声明方法

待更新……

面向对象高级篇

java复习八百页从头开始——案例、截图、源代码

Java相关栏目本月热门文章