精通Java学习之路（一）

本文章的图片由于是天香园1.0的但是过期了图片就查看不了，就当我自己的一个纪念了吧~

命运的齿轮开始转动~

img

Java三大特征：封装，继承和多态
成员变量：静态成员变量(static)和实例成员变

img

访问方法：类名.静态成员变量；对象.实例成员变量；对象.静态成员变量；（第三个不推荐）

img

套话：静态的都可以访问，实例的只能实例的访问

继承中子类不能继承父类的构造方法,eg:父类：public People(int age){this.age=age},子类就不能继承这个
@Override注释的用法

imgimg

子类重写方法的修饰符要比父类的更大或一样，EG：父类：protected,子类：public;
子类重写方法的返回值类型要比父类小或一样，RG:父类：public object run(){},子类:public Integer run(){};
继承后的全部（有参和无参）构造器一定会先访问父类的无参构造器，再执行子类自己的构造器；
子类的构造器第一行都有一个super();调用父类的无参数构造

何平安 18:44:36

引用类型作为方法的参数和方法的返回值：
先通过类进行创建对象

img

引用类型作为方法的参数：

img

引用类型作为数据类型(返回值)创建方法：

img~16XZP%60_PPPJ0VD(T_J@V.png)

，因为需要return 返回值，所以需要添加一个新的对象，如int等基本数据类型

三种方法设置引用类型的成员变量:

img7YN~PROH73V5ROF0K3WH.png)

c3类需要添加有参的构造方法（特别的引用类型添加方式：Address address）,还要有getter and setter设置这三个变量(两个基本类型变量和一个成员类型变量)
Address类：

img

，当然了也要添加三个变量的getter和setter方法

成员变量和方法学习时候的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class class1 {
private String name;
private int age;
private boolean sex;//实例成员变量，属于类的对象，需要添加对象进行访问
public static String schoolname="何平安la";//静态成员变量，属于类本身，可用类名直接访问
public class1(){
}
public class1(String name, int age, boolean sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public static void speakname(){
System.out.println("呜哈哈哈"+schoolname);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public void speak(){
System.out.println("name:"+this.name+",age:"+age+",sex:"+this.sex);
}
public static void main(String[] args) {
class1 zbj =new class1();
zbj.setName("猪八戒");
System.out.println(zbj.schoolname);
class1.speakname();//类名.静态方法
speakname();//同一个类中访问静态方法可以不写类名
zbj.speak();//对象.实例方法
zbj.speakname();//对象.静态方法（不推荐）
}
}

继承学习时候的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class c2 {
public static void main(String[] args){
c2 c =new c2();
People p1= new People();
Student s1=new Student();
s1.study();
}
static class People {
public People(){
System.out.println("人");
}
public String name;
public static void swim(){
System.out.println("游泳");
}
public void eat(){
System.out.println("吃饭");
}
public void run(){
System.out.println("跑步");
}
}
static class Student extends People{
public Student(){
// super(); 此处写不写都一样
System.out.println("学生");
}
public void study(){
System.out.println("学习");
eat();//调用子类的eat
super.eat();//调用父类的eat
//super可以在实例方法中调用子类中被重写的方法
}
@Override//加上注解后可以检查父类的方法是否写错，注释特点可读性好，安全，优雅~
public void eat(){
System.out.println("学生吃的多");//方法重写
}
// @Override
//此处方法名与父类的不一样，报错提示
public void run1(){
System.out.println("学生跑步");
}
public int id;
// @Override
public static void swim(){
}//静态方法不能被重写,因为静态方法只能用于自己的类，不能重写,单独写一样的方法相当于写了个新的静态方法，而不是重写
}

}

引用成员变量的代码：

主:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class c3 {
    private String name;
    private int age;
    private Address address;

    public c3(String name, int age, Address address) {

this.name = name;
        this.age = age;
        this.address = address;
    }
    public c3(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {

this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public static void main(String[] args) {
        Dog jinmao =new Dog();
        go(jinmao,1);
        //三种方法创造对象
        c3 hh = new c3();
        hh.setName(“何平安”);
        hh.setAge(18);
        hh.setAddress(new Address(“天香园”,22,33));//设置Address

        c3 hly= new c3(“何六一”,12,new Address(“嘉华园”,12,34));//有参构造函数

        c3 ch = new c3();
        ch.setName(“陈寒”);
        ch.setAge(19);
        Address addr =new Address(“嘉华园”,12,23);//可以新建一个创建Address
        ch.setAddress(addr);
        Address add1=ch.getAddress();
        System.out.println(ch.getName()+”住在”+add1.getName()+”,今年”+ch.getAge()+”岁了，地址坐标：”+add1.getX()+”,”+add1.getY());

    }
    public static void go(Dog a,int op){//引用类型作为方法的参数
        System.out.println(“开始”);
        a.run();
        System.out.println(“结束”);
    }
    public void eat(int age,String name){
        this.age=age;

this.name=name;
    }

    public static Dog createDog(){
        Dog taidi = new Dog();//创建一个新的对象，如下面的int和boolean类型，因为需要返回值
        return taidi;
    }
    //引用类型作为返回值
    public static int madeDog(){
        int abc=1;
        return abc;
    }

    public static boolean sexDog(){
        return true;
    }
    //通过引用类型创建方法
    static class Dog{
        public void run(){
            System.out.println(“狗跑步”);
        }
    }
    //创建类
}

Address类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Address {
private String name;
private double x;
private double y;
public Address(String name, double x, double y) {
this.name = name;
this.x = x;
this.y = y;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public double getX() {
return x;
}

public void setX(double x) {
this.x = x;
}

public double getY() {
return y;
}

public void setY(double y) {
this.y = y;
}
}