java笔记-基本概念（实例）

Java Reserved word·Java 关键字

下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

类别	关键字	说明
访问控制	private	私有的
-	protected	受保护的
-	public	公共的
类、方法和变量修饰符	abstract	声明抽象
-	class	类
-	extends	扩充,继承
-	final	最终值,不可改变的
-	implements	实现（接口）
-	interface	接口
-	native	本地，原生方法（非 Java 实现）
-	new	新,创建
-	static	静态
-	strictfp	严格,精准
-	synchronized	线程,同步
-	transient	短暂
-	volatile	易失
程序控制语句	break	跳出循环
-	case	定义一个值以供 switch 选择
-	continue	继续
-	default	默认
-	do	运行
-	else	否则
-	for	循环
-	if	如果
-	instanceof	实例
-	return	返回
-	switch	根据值选择执行
-	while	循环
错误处理	assert	断言表达式是否为真
-	catch	捕捉异常
-	finally	有没有异常都执行
-	throw	抛出一个异常对象
-	throws	声明一个异常可能被抛出
-	try	捕获异常
包相关	import	引入
-	package	包
基本类型	boolean	布尔型
-	byte	字节型
-	char	字符型
-	double	双精度浮点
-	float	单精度浮点
-	int	整型
-	long	长整型
-	short	短整型
变量引用	super	父类,超类
-	this	本类 this.属性名称
-	-	指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
-	void	无返回值
保留关键字	goto	是关键字，但不能使用
-	const	是关键字，但不能使用
-	null	空

Java 对象和类

对象 object

• 对象：狗 – class
• 属性：品种、年龄、颜色 – variable/
• 行为：叫、摇尾巴、饥饿 – method [main]

public class Dog{
	String breed;//String 开头必须大写，string不会变色诶
	int age;//定义变量，属于成员变量，对应实体entities中的属性attitude
	String color;//通过声明/定义属性s来构造对象

	void bark(){//method 相当于函数
	}
	void sleep(){
	}
	void run(){
	}
 }

	变量
	局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。
	变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
	* 成员变量：成员变量是定义在类中，方法体之外的变量。
	* 	这种变量在创建对象的时候实例化。
	* 	成员变量可以被类中方法、构造方法和特定类的语句块访问。	
	* 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

• 一个类可以拥有多个方法，在上面的例子中 ： bark () 、 sleep () 和 run () 都是 Dog 类的方法。

构造方法method

1. 每个类都有构造方法。
   在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Dog{
	public Dog(){
	}
	public Dog(String name){
	//这个构造器只有一个参数 name 类型String}
}

创建对象!!!

1. 对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。

    声明：声明一个对象，包括对象名称和对象类型。
   
    实例化：使用关键字new来创建一个对象。
   
    初始化：使用new创建对象时，会调用构造方法初始化对象。
   

   实例：

public class Dog{
	public Dog(String name){
	System.out.println("小狗的名字是："+name};
	}
	public static void main(String[] args){
	Dog mypuppy = new Dog ("Alex");
	//调用构造的方法 Dog， 构建新变量命名为 mypuppy， 
	//类型 String， 赋值/初始化 mypuppy = “Alex” ，执行：打印；
	//迷思1：为什么方法DOG要用public，这不是一个函数吗，名字和类型不能随便选择？
	//知识点：entry point is main method.所以每一个函数都要有一个method
	}
	 
}

程序结果：

小狗的名字是：Alex

完全版实例

public class Dog {
    int puppyAge;//声明/定义程序变量
    public Dog(String name){
        System.out.println("Puppy's name is "+name);
    }//用在main method中，用于创建对象dog
    
    public void setAge( int age){
        puppyAge = age;
    }//表示需要输入一个int数值在调用的括号中，然后自动初始化给本method中的参数age ，
    // 然后赋值给程序变量/公共变量puppyAge；

    public int getAge(){
        System.out.println("Puppy's age is "+puppyAge);
        return puppyAge;// 这个在main块之外，成员变量
        //迷思2：这个return有什么用？是为了呼应int吗？那为什么要用int？
        	//如果说其作用就是打印出age的话？}
        
    public static void main(String [] args){
       /*创建对象*/
        Dog mypuppy = new Dog ("Alex");
        //调用构造的方法 Dog， 构建新变量命名为 mypuppy， 类型 String， 赋值/初始化 mypuppy = “Alex” ，执行：打印；
        //迷思1：为什么方法DOG要用public，这不是一个函数吗，名字和类型不能随便选择？
        //知识点：entry point is main method. 所以每一个program都要有一个main method。
        mypuppy.setAge (2);//mypuppy. 开头是什么骚操作？
        mypuppy.getAge();
        /*访问程序变量puppyAge*/
        System.out.println("程序变量："+mypuppy.puppyAge);//why不加“mypuppy."就会报错？
        //迷思3：mypuppy在这里究竟是什么？一个变量名字？还是一个包一样的thing？
    }
}

程序结果：

Puppy’s name is Alex
Puppy’s age is 2
程序变量：2

迷思1！！！

public Dog(String name){
System.out.println("Puppy’s name is "+name);
构造器的基本语法

public void setAge( int age){
puppyAge = age;
赋值？的基本语法

public int getAge(){
System.out.println("Puppy’s age is "+puppyAge);
return puppyAge;
这个执行println的为什么需要return？但是最后那个程序甚至就是public void完事儿？
好了老子改了，改成了
public void getAge(){
System.out.println("Puppy’s age is "+puppyAge);
}（去掉了return&把int 改成了void）
毫无破绽，正常运行。

源文件声明规则

一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么package语句应该在源文件的首行。
如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

来源：

https://www.runoob.com/java/java-object-classes.html

Java包 Import语句

1. 对类和接口进行分类路径的提供
   因为在develop program 时，可能会用到成百上千个程序，所以只要使用“包”，就可以把一个程序中不同功能的code写在不同的file里面

Import语句
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*;其实可以随便写一个包？

Java 包实例

import java.io.*;
 
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

import java.io.*;
public class EmployeeTest{
 
   public static void main(String[] args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }

名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

本地program

1. TWEBEmployee

包含构造器和调用状态

import java.util.*;//这个是我乱打的。
public class TWEBEmployee {
    String name;
    int age;
    double salary;
    String designation;
    /*Employee类的构造器*/
    public TWEBEmployee(String name){//这里一定不能加上void 这样就会test失败；这个（）里面实际上参数的名字可以不是name，这样就不用在后面都code中声明this.了。（吧？）就像下面的age一样？
        this.name = name;
    }
    //以下全部都是赋值类的    /*设置age的值*/
    public void empAge(int empAge){
        age = empAge;
    }    /*设置designation的值*/
    public void empDesignation(String empDsig){
        designation = empDsig;
    }    /*设置salary的值*/
     public void empSalary(double empSalary){
        salary = empSalary;
     }    /*打印属性*/
    public void printEmployee(){
        System.out.println("名字："+name);
        System.out.println("年龄："+age);
        System.out.println("职位："+designation);
        System.out.println("薪水："+salary);
    }
}

2. TWEBEmployeeTest

尝试构造两个对象，并且打印

import java.util.*;
public class TWEBEmployeeTest {
    public static void main(String[ ] args){
       //使用构造器构造两个对象
       TWEBEmployee emp1 = new TWEBEmployee("RUNOOB1");//这里之前一直报错，原因：Error:(6, 28) java: 无法将类 com.company.TWEBEmployee中的构造器 TWEBEmployee应用到给定类型;  需要: 没有参数  找到: java.lang.String  原因: 实际参数列表和形式参数列表长度不同
       //是因为之前的public写错，多加了一个void
       TWEBEmployee emp2 = new TWEBEmployee("RUNOOB2");
       //调用成员变量赋值 method
       emp1.empAge(18);
       emp1.empDesignation("学生");
       emp1.empSalary(0);
       emp1.printEmployee();
       emp2.empAge(20);
       emp2.empDesignation("大学生");
       emp2.empSalary(400);
       emp2.printEmployee();
    }
}

程序结果：

名字：RUNOOB1
年龄：18
职位：学生
薪水：0.0
名字：RUNOOB2
年龄：20
职位：大学生
薪水：400.0

迷思2！！！

key：第一块代码 对象的构造方法 注意事项：
public方法名与class名一致；
构造方法是public + classname，不用加void
import其实可以随便写？

大约使用构造方法构造的emp1、emp2其实类似一个对象？包含各种定义在第一个代码块里的属性？