Java复习基础之我和“对象”的故事(一)

程序员文章站 2022-07-05 11:51:02

...

今天呢，呼，终于看到这个了，心头一轻，数组看着真是费脑子，哈哈，吐槽归吐槽，还是要继续的，继续磨刀。
今天要说的是面向对象，脑子中可能会有一个大大的问号？，什么是面向对象？可能我们经常会说，面向对象编程，这个词语，今天呢，就来说说这个面向对象到底是什么,个人见解，基于自己的理解，要是有不对之处，希望大家指正!!

1 首先记住一句话，万物皆可“对象”，接下来在说

一、首先要理解以下几个概念，
1 什么是类？
通常我们所说的一类人，到低是什么？首先，类，是一个抽象的，概念性的东西，是对一种事务的描述。
2 什么是对象？
程序，它是和现实生活中关联密不可分的，对象，是一类事务的每个个体。可以看做是一个具体的子类
3 类和对象之间有什么关系？
首先从范围上来说，类包含对象，对象是一个类的具体化，实例化，表现话，对象是类new 出来的。 OK，不多说，就记这么多。

小结：
1 在回头来看，万物皆可 “对象”，它可以理解为，只要我们能够描述一个类，那我们就可以通过类，去实例化一个对象来表现出来，你让它什么样子，它就是什么样子，在之后的知识中，你会发现，类，对象，无处不在！！.
2 面向对象编程：透过对象看本质，对象，是由类new出来的，也就是说，还是要看类的结构，SO,面向对象编程， 实质上，类的设计是重点.

2 有了类和对象的基础知识之后，从整体上来说：

一、首先，类的结构有以下几点：
1 属性，方法，构造器，代码块，内部类
2 关键字:this、super、static、final、abstract、interface、package、import等
3 面向对象的大特征：封装、多态、继承
二、接下来，通过一段代码来具体说明上面的知识点

//1.创建类，设计类的成员
class Person{
	//属性
	String name;
	int age = 1;
	boolean isMale;

	//构造器
	public Person() {
	}
	//有参构造器
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//方法
	public void eat(){
		System.out.println("人可以吃饭");
	}
	public void sleep(){
		System.out.println("人可以睡觉");
	}
	public void talk(String language){
		System.out.println("人可以说话,使用的是：" + language);
	}
}

接下来就是 对象的调用了
//测试类
public class PersonTest {
	public static void main(String[] args) {
		//2. 创建Person类的对象,使用哪个类，就先new对象，把它具体化，实例化.
		Person p1 = new Person();
		//调用对象的结构：属性、方法
		//调用属性：“对象.属性”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		//*******************************
		Person p2 = new Person();
		System.out.println(p2.name);//null
		System.out.println(p2.isMale);
		//*******************************
		//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		
		p3.age = 10;
		System.out.println(p1.age);//10
	}
}

小结：通过这个类和对象，我们可以联想到其他的类和对象，也是如此，通过类的实例化，去调用对象的方法，来展示不同的功能。这样复习，能够发散自己的思维，加深类和对象的概念。

知识回顾：
1 我们在之前的基础知识中，有一个 Scanner类，回想它的用法：
Scanner scanner= new Scanner(System.in); 对比类和对象
Person p1=new Person(); Person类是我们自己定义的，Scanner是定义好的，我们拿来用它的方法，这个地方也能体现类和对象，无处不在！！

2 还有一点：我们之前说数据类型分为 4类8中，其中，引用数据类型中，就包括：类，数组，接口，因此，在面向对象当中，当有人说，我这个类是引用数据数据类型，你说不对，就比较尴尬了。我们自己定义的一个类，也是一个引用数据类型，也可以拿来用.比如我们写一个自定义的工具类，我们也可以通过自定义一个工具类去调用我们想要的方法，SO，这里的一个体现，就是类的设计的重要性了，
3 上面啰嗦一大堆，总结来说，这就是面向对象思想的落地体现，至于别的知识点，接下来在不断的深入.

3 有了类和对象的基础知识之后，从细节上来说：

一、类中的属性：又称为成员变量，当然还有局部变量，他们的相同点和不同点如下：

1.相同点：

 1.1  定义变量的格式：数据类型  变量名 = 变量值

```
 1.2 先声明，后使用
```
```
 1.3 变量都有其对应的作用域
```
2.不同点：
```
 2.1 在类中声明的位置的不同
```

 属性：直接定义在类的一对{}内

 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

class User{
    //属性（或成员变量）
    String name;
    public int age;
    boolean isMale;


    public void talk(String language){//language:形参，也是局部变量
        System.out.println("我们使用" + language + "进行交流");

    }
    public void eat(){
        String food = "烙饼";//局部变量
        System.out.println("北方人喜欢吃：" + food);
    }
}

 //1 Uer类的实例化，创建User的对象
        User user=new User();
        System.out.println(user.age); //打印输出 年龄, int  类型, 0 
        System.out.println(user.name); //打印输出 姓名 String 类型 null    
        System.out.println(user.isMale); //打印输出 性别 boolean类型 false

Tips: 定义一个变量，我们可以看到，数据类型，它的默认值可以关注一下! 正是我们前面所说的，可以说是，前面的瓦块在奉献着它的力量,

二、接下来就是类的方法:

1 记住这一点：方法的声明：
权限修饰符返回值类型方法名(形参列表){

```
 			方法体
```
```
 	 }
```
举例如下,我们常说的 main方法,哈哈，这个经典：

	  public static void main(String[] args){
		方法体
	}

2上面的方法中的权限修饰符，返回值类型等等，接下来就会说这个.
1 权限修饰符：
Java规定的权限修饰符: private public 缺省, protected —>封装性会体现的更加明显
2 返回值类型：对一个方法来说，有没有返回值，取决于题目的要求，举例如下：

public void setAge(int age){  } //设置一个年龄，它不需要返回值，
public int  getAget(int age){  } //这里就需要一个返回值类型，来表明年龄是一个整型

三、接下来就是类的构造器

1 构造器的作用：
1 创建对象
2 初始化对象的信息
举例如下：

	public Person(){
			System.out.println("Person().....");
		}
	public Person(String n){
			name = n;		
		}
	public Person(String n,int a){
		name = n;
		age = a;
	}
	上面这个就是 要说的构造器，可以说是 一个 类的 主体部分就复习完了，能做到心中有沟壑，想必做起来也会游刃有余一些。

四、类的主体说完之后，接下来就是面向对象的特征之一：封装性。

1 什么是封装性？
举例来说，生活中的洗衣机，从程序上看来说，它就具有这个特征，我们看不到它的内部构造，不用去关心它的构造原理，拿来用就行。OK，下面来说 Java中的封装性
2 我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
3 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
4 接下来就是封装性代码的体现:

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius; //类中的属性
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法

体现三：单例模式（将构造器私有化）

体现四：如果不希望类在包外被调用，可以将类设置为缺省的

 Tips： 权限从小到大顺序为：private <  缺省 < protected < public
		4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
		修饰类的话，只能使用：缺省、public
通过权限修饰符，我们可以对一个类的属性，或者方法，区分的更加 分明，这样有助于我们 对代码的掌控，什么能做，什么不能做。OK，今天就先说这么多，明天把 面向对象的两个特征说完，在说一些 面向对象的习题，代码不能停，在把 java基础的 异常处理说完，java基础就算是说完了，在过两天，把java高级部分，在说一说，javaweb 的在说一说，这个春节就算过完了，紧张，充实，就该要实习了，加油！

上一篇： Mysql中大数据的批量插入方法比较

下一篇：在有数据的情况下更改oracle数据库的字段类型