从头开始学Java--类和对象

迷南。 2022-08-14 04:49 167阅读 0赞

## 一.啥也不说了，先来个helloworld ##

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

Java不像C++那样“用C++的语法，写C语言的代码”，连Helloworld都要封装到一个类里面，彻底的面向对象。个人感觉十分有助于培养面向对象的思维方式。最开始学C到用C++，感觉总是不彻底的面向对象，写着写着就变成了结构化编程。这下好了，想不写一个类都不成！

**要点：1.main方法是程序的入口点，由java虚拟机调用，必须按照格式书写。**

**2.main方法属于static方法，即不创建对象也可调用的方法。**

**3.System.out.print与System.out.println为输出函数，类似与cout，都可以接受输出的内容，包括一些特殊字符（如\\n），前者是输出，后者是输出一行（自带换行功能）。System是类名，out是一个字段，System.out是java提供的标准输出对象，print与println为两个方法。**

语法部分看过了一些，跟C/C++大概差不多，所以就不记录了。还是记下来一些Java的特性。

## 二.来一个类 ##

class Myclass1 {
    	private int value;
    	private String name;
    
    	public void setValue(int v)
    	{
    		value = v;
    	}
    	public int getValue()
    	{
    		return value;
    	}
    	public void setName(String s)
    	{
    		name = s;
    	}
    	public String getName()
    	{
    		return name;
    	}
    }
    
    public class TestMyClass1
    {
    	public static void main(String[] args)
    	{
    		Myclass1 myclass1 = new Myclass1();
    		myclass1.setName("hello");
    		myclass1.setValue(1);
    		System.out.println("value is " + myclass1.getValue() + " name is " + myclass1.getName());
    	}
    }

跟C++的差不太多，只是main函数也是需要封装在一个类里面。而且main函数也是需要有固定的格式。

**要点：1.java类命名规范：每个单词首字母大写，eg：TestMyClass**

**2.java文件命名规范： java文件名 = 公有类名 + .java。一个.java文件中可以有多个类，但是只能有一个公有类。**

**3.java变量&函数命名规范：常量全大写eg： MAX\_VALUE，函数名第一个单词小写，后面单词第一个字母大写eg：getValue()。**

## 三.引用类型变量 ##

java中除了少数的几个原始数据类型，如int,char, float等，其他的变量都为引用数据类型。

所谓引用数据类型，就是在内存中建立一个对象，用一个变量引用这个对象。

例如：Myclass1 myclass1 = new Myclass1();

前半句 Myclass1 myclass1 就是创建了个Myclass1类型的引用变量，但是这个变量并没有实际的对象。此时myclass1 = null.

后半句new Myclass1()，调用了类的构造函数，产生了一个对象。并且用前面的myclass1引用这个对象。

![Center][]

这里面 = 赋值的仅为内存地址值，并不是将对象赋给引用类型的变量。只是让引用变量可以找到内存中的对象。

一个例子：

class Myclass {
    	private int value;
    	private String name;
    
    	public Myclass(int v, String n)
    	{
    		value = v;
    		name = n;
    	}
    }
    
    public class TestMyClass
    {
    	public static void main(String[] args)
    	{
    		Myclass myclass1 = new Myclass(1, "zhang");
    		Myclass myclass2 = new Myclass(1, "zhang");
    		Myclass myclass3 = myclass1;
    		System.out.println(myclass1 == myclass2);
    		System.out.println(myclass1 == myclass3);
    	}
    }

结果如下：

![Center 1][]

两个内容都一样的对象，却不相等。可见，对于两个引用类型的变量，判断 == 是判断两个引用类型的变量是否指向一个相同的对象。

上面程序可以用下图表示：

![Center 2][]

**要点：1.引用类型的变量，存储的并不是实际的对象。而是对象的地址。 = 赋值也只是将地址赋值给另一个引用类型的变量。内存中对象仍然只有一份。**

**2.即使创建的两个对象内容完全相同，用 == 判断的也是对象的地址是否相同，所以只要不是两个引用类型变量指向同一个对象，都是不相等的。**

**3.如果要判断两个对象内容是否相等，可以重写equals方法，或者重载equals方法。**

## 四.构造函数&类的初始化块 ##

看一个例子：

class InitClass
    {
    	//flag默认值
    	public int flag = 100;
    	//类的初始化块
    	{
    			flag = 200;
    			filed = 200;
    	}
    	//filed默认值
    	public int filed = 100;
    	
    	//无参数构造函数
    	public InitClass()
    	{
    		
    	}
    	//重载：带参数构造函数
    	public InitClass(int falg, int filed)
    	{
    		this.flag = falg;
    		this.filed = filed;
    	}
    	
    }
    
    public class InitTest {
    	public static void main(String[] args)
    	{
    		InitClass initclass1 = new InitClass();
    		System.out.println("flag: " + initclass1.flag + " filed:" + initclass1.filed);
    		
    		InitClass initclass2 = new InitClass(300, 300);
    		System.out.println("flag: " + initclass2.flag + " filed:" + initclass2.filed);
    	}
    }

输出如下：

![Center 3][]

**要点：1.如果不写构造函数，系统提供无参数的默认构造函数。只建立对象，不赋值。如果定义了构造函数，那么系统将不提供默认构造函数。如果需要无参数构造函数则需要自己写。可以重载构造函数，提供不同参数的构造函数。**

**2.初始化时执行的顺序： 第一步执行成员定义，有定义时默认赋值和初始化块，同时有这两个的时候，两者按照顺序执行。第二步执行构造函数。**

## 五.类的静态字段&静态方法 ##

举个栗子：

class StaticDemo
    {
    	//静态成员属性
    	static int value = 100;
    	//静态初始化块
    	static 
    	{
    		value = 200;
    	}
    	//静态方法访问静态成员属性
    	public static void staticPrint()
    	{
    		System.out.println(value);
    	}
    }
    
    public class StaticTest {
    	public static void main(String[] args)
    	{
    		//直接访问静态属性
    		System.out.println(StaticDemo.value);
    		
    		//建立对象，通过对象访问静态成员属性
    		StaticDemo staticdemo = new StaticDemo();
    		System.out.println(staticdemo.value);
    		
    		//直接访问静态方法
    		StaticDemo.staticPrint();
    	}
    }

**要点：1.静态成员变量或方法可以通过两种方式访问。一种是直接用类名.属性（或方法），一种是建立对象，通过对象.属性（或方法）。但是推荐直接使用类名调用。**

**2.静态成员函数只能访问静态成员变量，不能访问非静态的成员变量。**

**3.静态初始化块的调用与初始化块调用一样。但是静态初始化块只执行一次。一个类只有一份静态成员，不管建立了几个对象。**

[Center]: /images/20220810/82b94e977b994170b2562546d0569377.png
[Center 1]: /images/20220810/4293d742002e4353b79af3a171ac203f.png
[Center 2]: /images/20220810/d9fe9fb59a884cdda71ab0dbdb0f6f74.png
[Center 3]: /images/20220810/3e1fa062ad4346ffa905a0bd109e266c.png