文章目录

  • 一、类与对象
  • 1.对类和对象的理解
  • 2.类和类的实例化
  • 3.类的成员
  • 3.1 字段
  • 3.2 方法
  • 3.3static关键字
  • 4.封装
  • 4.1 private实现封装
  • 4.2 getter/setter方法
  • 5.构造方法
  • 5.1 基本语法
  • 5.2 this关键字


一、类与对象

1.对类和对象的理解

1.类：定义了对象具有的特征和行为。也就是一类对象的统称。
 2.对象：拥有多个特征和行为的实体。也就是这一类具体化的实例。
 3.特征：称为属性，一般为名词，代表对象有什么。
 4.行为：称为方法，一般为动词，代表对象可一做什么。

2.类和类的实例化

1.类就是一类对象的统称，对象就是这一具体化的实例。
下面展示一些 基本语法。

// 创建类
class <class_name>{
	filed;//成员属性
	method;//成员方法
}
//实例化对象
<class_name> <对象名> = new <class_name>();

其中class为定义类的关键字，ClassName为类的名字，{ }中为类的主题。
类中的元素称为：成员属性。类中的函数称之为：成员方法。

2.类的实例化：用类类型创建对象的过程，即为实例化。
下面展示一些 示例代码。

class Person{
	public int age;//成员变量
	public String name;
	public String sex;
	public void eat(){//成员方法
		System.out.println("实现了eat()!");
	}
	public void play(){
		System.out.println("实现了play()!");
	}
}
public class Main{
	public static void main(String[] args){
		Person p=new Person();//通过new实例化对象
		p.eat();//成员方法调用需要通过对象的引用调用
		p.play();
		//产生对象     实例化对象
		Person p2=new Person();
		Person p3=new Person();
	}
}
输出的结果为：
     实现了eat()!
     实现了play()!

3.类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等。先介绍前三个。

3.1 字段

class Person {
    public String name;   // 字段    默认值为null
    public int age;
}
public String name = "张三";    //字段的就地初始化
    public int age = 18;

3.2 方法

class Person {
    public int age = 18;
    public String name = "张三";
    public void show() {  //方法	
   System.out.println("我叫" + name + ", 今年" + age + "岁");
   }
}

方法中还有一种特殊的方法称为 构造方法：在实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于对象的初始化。
虽然我们前面已经能将属性就地初始化, 但是有些时候可能需要进行一些更复杂的初始化逻辑, 那么就可以使用构造方。

3.3static关键字

1.修饰属性：Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性。
class TestDemo{
    public int a;
    public static int count; }
public class Main{
    
 public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);//1
        System.out.println(TestDemo.count);//1
        System.out.println("============");
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);//1
        System.out.println(TestDemo.count);//2
   }
}
输出结果为：
1
1
============
1
2

2.修饰方法：如果在任何方法上应用 static 关键字，此方法称为静态方法。

  • 静态方法属于类，而不属于类的对象。
  • 可以直接调用静态方法，而无需创建类的实例。
  • 静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
class TestDemo{
    public int a;
    public static int count;
    public static void change() {
        count = 100;
        //a = 10; error 不可以访问非静态数据成员
   }
}
public class Main{
	public static void main(String[] args) {
        TestDemo.change()；//无需创建实例对象 就可以调用
        System.out.println(TestDemo.count);   
   }
}
输出结果为:
100

4.封装

1.概念：尽可能隐藏对象的内部实现细节，控制对象的修改即访问权限。
2.private的访问修饰符，修饰属性，达到本类可见的效果。
3.get/set方法是外界访问私有属性的唯一通道，方法内部可对数据进行过滤。（可在set方法中添加过滤条件）
4.提供公共访问方法，以保证数据可以正常录入。

4.1 private实现封装

下面展示 public和private的比较。

class Person {
 public String name = "张三";
 public int age = 18; }
class Test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
   }
}
执行结果：
我叫张三，今年18岁
  • 这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高。
  • 一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高。
class Person { 
 private String name = "张三"; 
 private int age = 18; 
 
 public void show() { 
 System.out.println("我叫" + name + ", 今年" + age + "岁"); 
 } 
} 
class Test { 
 public static void main(String[] args) { 
 Person person = new Person(); 
 person.show(); 
 } 
}
执行结果：
我叫张三，今年18岁
  • 此时字段已经使用 private 来修饰。 类的调用者(main方法中)不能直接使用。而需要借助 show 方法。此时类的使用者就不必了解 Person 类的实现细节。
  • 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段)。

4.2 getter/setter方法

下面展示一些 示例。

class Person { 
 private String name;//实例成员变量
 private int age; 
 
 public void setName(String name){ 
 //name = name;//不能这样写
 this.name = name;//this引用，表示调用该方法的对象
 } 
 public String getName(){ 
 return name; 
 }  
 public void show(){ 
 System.out.println("name: "+name+" age: "+age); 
 } 
} 
public static void main(String[] args) { 
 Person person = new Person(); 
 person.setName("李四"); 
 String name = person.getName(); 
 System.out.println(name); 
 person.show(); 
}
运行结果：
李四
name:李四 age:0

5.构造方法

5.1 基本语法

1.概念：类中的特殊方法，主要用于创建对象。
2.特点：

  • 名称与类名完全相同（包括大小写）。
  • 没有返回值类型。
  • 创建对象时，触发构造方法的调用，不可通过句点的形式手工调用。

3.注意：

  • 如果没有在类中显示定义过构造方法，则编译器默认提供无参构造方法。
  • 如果已经手动添加过有参构造方法，则无参构造方法不在默认提供，可结合需求自行添加。

5.2 this关键字

  1. this代表“当前实例”，即是模板中的当前对象，模板服务与哪个对象，this就指向哪个对象。
  2. this第一种用法：调用本类中的实例属性、实例方法。例如：this.name、this.run() 。
  3. this第二种用法：调用本类中的其他构造方法。例如：this()、this(实参)。注意：必须在构造方法的首行。
  4. 默认来讲，实例属性和方法前的this.隐式存在。