类与对象的回顾

类与对象

什么是类

类是一个模板，它描述一类对象的行为和属性。

对象：对象是类的一个实例，有 属性 和 行为 。

人是一个 “类”，小明就是人的 “对象” ，女生/男生是一个类，你的女朋友/男朋友就是一个对象，这个对象的属性有：名字，性别，年龄；行为有：吃饭、睡觉、学习等。

在Java中对象的状态就是属性，行为通过方法体现，即Java中的对象一般由属性和行为组成。

怎么定义类

需要使用class,声明这个类的名字。
举例说明：

class Student(){
//声明这个是一个学生类
}

学生类中有年龄，姓名，性别属性，方法为吃饭，睡觉和学习。

class Student(){
 	int age;
 	String name;
 	String sex;
 	void eat(){
 	 	System.out.printn(name+"正在吃饭");
 	}
 	void sleep(){
 		System.out.println("睡觉");
 	}
 	void study(){
 		System.out.println("学习");
 	}
}

创建对象并且使用对象的属性和方法

public class Test(){
	public static void main(String[] args){
		//创建了S1对象
		Student s1 = new Student();
		
		//设置对象的属性
		s1.name = "小明";
		s1.age = 12;
		s1.sex = "男";
		
		System.out.println(s1.name+ s1.age);
		
		//调用对象的方法
		s1.eat();
		s1.sleep();
		s1.study();
	}
}



class Student(){
	int age;
	String name;
	String sex;
	void eat(){
 	 	System.out.printn(name+"正在吃饭");
 	}
 	void sleep(){
 		System.out.println("睡觉");
 	}
 	void study(){
 		System.out.println("学习");
 	}
}

综上我们可以发现创建对象使用的公式就是：

类名 对象名 = new 类名();

给对象的属性赋值：
对象名.属性名 = 值;
使用对象的属性：
对象名.属性名
调用对象的方法：
对象名.方法名();

构造方法

什么是构造方法

构造方法：对象被创建的时候会调用的方法，对象在被创建的时候，也就是被new的时候，会自动调用构造方法。

举个例子：

public class Test{
	public static void main(String[] args){
		Person p = new Person();
	}
}


class Person(){
	public Person(){
		System.out.println("我被调用了");  // ->  构造方法
	}
}

​

怎么定义和使用构造方法

class Student(){
	String name;
	int age;
	
	public Student(){
		System.out.println("构造方法");
	}
    
    public Student(String stuName){
        name = stuName;
        System.out.println("有参数构造方法");
    }
    
    
    
    public void hello(){
        System.out.println("普通方法");
    }
    
    public int hello(int score1,int score2){
        return (score1+score2)/2;
    }
	
}

1. 构造方法可以有参数，也可以无参数；
2. 构造方法无返回值，也不需要声明void关键字；
3. 构造方法名必须和类名相同。

成员变量

成员变量就是对象的属性

this关键字

关于this关键字，你只需要记住它就是指自身，this即代表自己，this.属性访问的是自己的属性、this()访问的就是自己的无参构造方法。

class Person(){
	String name;
	
public Person(String name){
	this.name = name;   //自身的属性
}
}

public class HelloWorld(){
	public static void main(String[] args){
		Person p1 = new Person("张三");
		System.out.println(p.name);
	}
}

class Person(){
    String name;
    
    public Person(){
        System.out.println("I am");
    }
    
    public Person(String name){
        this();   //调用的构造方法只能写在第一行
        this.name = name;
        
    }
}

static关键字

什么是static关键字

static是静态的意思，是一个修饰符，就像是一个形容词，是用来形容类，变量，方法的。

static修饰变量，这个变量就变成了静态变量，修饰方法这个方法就成了静态方法，

static关键字方便在没有创建对象的情况下来进行调用（方法/变量）。

static关键字的作用

static关键字你可以理解为是一个形容词，一般是用来形容类、方法、变量、代码块，还有一个作用是用来静态导包

1. 修饰变量

   不使用static关键字访问对象的属性：

   Public class Test{
   	
   	public static void main(String[] args){
   		Person p = new Person();
   		p.name = "张三";
   	}       //需要先创建对象才能设置对象的属性
   }
   
   class Person(){
   	String name;
   	int age;
   }
   

   使用static关键字访问对象的属性：

   Public class Test{
   	
   	public static void main(String[] args){
   		Person.name = "张三";
   	}       //使用static关键字修饰的变量
       		//可以通过  类名.属性名  直接访问
   }
   
   class Person(){
   	static String name;
   	int age;
   }
   

**注意：**如果一个类的成员变量被static修饰了，那么所有该类的对象都共享这个变量。无论这个类实例化多少对象，它的静态变量只有一份拷贝。
如：

public class Test(){
	public static void main(String[] args){
		Person p1 = new Person();
         p1.name = "张三";
         Person.name = "李四";
         Person p2 = new Person();
         Person p3 = new Person();
        
         System.out.println(p1.name);  //李四
         System.out.println(p1.name);  //李四
         System.out.println(p1.name);  //李四
	}
}

class Person{
	static String name = "张三丰";
}

2. 修饰方法

   用static关键字修饰的方法叫做静态方法。静态方法我们已经用过，它有一个特点相信你已经很熟悉，那就是不需要创建对象就可以直接使用。

   如：

public class Test{
	public static void main(String[] args){
		Person.hello();    //静态方法，只需类型.方法名即可
         Person p1 = new Person();
         p1.hi();
	}
}

class Person{
    public static void hello(){
        System.out.println("hello");   //静态方法
        
    }
    
    public void hi(){
        System.out.println("hi");    //普通方法
     
    }
}

注意：

1. 静态方法不能使用类的非静态变量；
2. 静态方法可以直接调用静态方法，但是调用普通方法只能通过对象的实例才能调用.

public class Test(){
	public static void main(){
		hello();
		
		
		Test t = new Test();
		t.hi();   // 普通方法的调用需要创建对象
	}
	
	public static void hello(){
		System.out.println("hello");
	}
	
	public void hi(){
		System.out.println("hi");
	}
}

静态代码块

在类被加载的时候运行且只运行一次。