Java第一周周记

第二章

2.1注释

为了方便程序的阅读，提高程序的可读性，在Java中可写上一些说明行的文字，即注释。根据注释的功能不同，主要分为单行注释、多行注释和文档注释。

• 单行注释： 使用“//”开头
• 多行注释： 以“/”开头，以“*/”结尾
• 文档注释： 以“/**”开头，以“*/”结尾

【示例2-1】认识Java的三种注释类型

/**
 * 用来测试注释的用法（包含：单行注释、多行注释、文档注释）
 * @author 15386
 *
 */
public class TestComment{
    
/**
 * 这是程序的入口
 * @param args
 */
    public static void main(String[] args/*args是参数名，可以修改*/) {
        System.out.println("测试注释！");//这是打印语句
        
    }
    
}

/* 
 * 我是多行注释！
 * 
 * 
 * 
 */

2.2标识符规则

• 标识符必须以字母、下划线、美元符号$开头i。
• 标识符其他部分可以是字母、数字、下划线、美元符、数字的任意组合。
• 标识符大小写敏感，长度无限制
• 标识符不可以是Java的关键字

/**
 * 测试标识符的用法
 * @author 15386
 *
 */
public class Testidentifer {

    public static void main(String[] args) {
        int a123=1;
        //int 123abc=2;//数字不能开头
        int $abc=3;
        int _abd=5;
        //int #and=6;
        int 年龄=18;        
    }
}

 2.3   Java中的关键字/保留字

2.4.1   Java中变量的本质__声明格式和初始化问题

        double占8个字节   ；  long 占8个字节  ；   int   占4个字节

2.4.2   变量分类

• 局部变量

         先声明再使用

• 成员变量 
• 静态变量：用static定义

2.5   常量

 变量和常量命名的规范：

         1.类成员变量：首字母小写和驼峰原则:monthSalary

         2.局部变量：首字母小写和驼峰原则

         3.常量：大写字母和下划线:MAX_VALUE

         4.类名：首字母大写和驼峰原则

        5.方法名：首字母小写和驼峰原则:run(),runRun()

2.6   基本数据类型（8个）

• 数值型{整数类型：（byte（1个字节），short（2个字节），int（4个字节），long（8个字节））
•             浮点类型： （float（4个字节），double（8个字节））}
• 字符型char  (2个字节)
• 布尔型boolean  （1位）

2.6.1  整型变量/常量 

 Java语言整型常量的四种表示形式

• 十进制整数
• 八进制整数，要求以0开头
• 十六进制整数，要求以0x开头
• 二进制整数,要求以0b开头

2.6.2  浮点型变量

表示形式：

• 十进制形式：314.0
• 科学计数法形式：314E2

使用精确的浮点运行，推荐：BigDecimal

2.6.3  字符型变量/常量

2.6.4  boolean类型

          不要这样写：if(flag==true)   ，直接写：if(flag)

2.7.1 算数运算符

整数运算：

•  如果两个 *** 作数有一个是long,则结果也是long
• 没有long时，结果是int。即使 *** 作数全为short，byte，结果也是int

浮点运算：

• 如果两个 *** 作数有一个是double，则结果为double
• 只有两个 *** 作数都是float，则结果才为float

取模运算：

7%3=1，-7%3=-1.

2.7.3  关系运算符

  1.其运算结果是布尔值：true/false

2.7.7  条件运算符

     格式：x?y:z

第三章

3.1    控制语句

• if单选择结构

     语法结构：if（布尔表达式）{    }

• if-else 双选择结构
• if-else多选择结构
• switch结构（多值判断）

基本结构：

switch(表达式）{

case 值1：

语句1；

break;

default:

默认语句；

}

3.2循环结构    while循环（先判断，后执行）

语法结构：

while（布尔表达式）{

         循环体；}

for循环

/**
 * 测试if循环
 * @author 15386
 *
 */
public class TestFor {
	public static void main(String[] args) {
		int sum=0;
		for(int i=1;i<=100;i++)
		{sum=sum+i;}
		/**
		 * 1.执行初始化语句：i=1；
		 * 2.判断i<=100
		 * 3.执行循环体
		 * 4.步进迭代：i++
		 * 5.回到第二步继续判断
		 */
		
		for(int i=1,j=i+10;i<5;i++,j=i*2) {
			System.out.println("i="+i+"j="+j);
		}
		
		for(;;) {//while（true）{
			System.out.println("爱你到永远！！");
		}
		
	
	}
}

嵌套循环

break和continue语句

     continue用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否循环的判定。

• 示例：continue语句：把100-150之间不能被3整除的数输出，且每行输出5个

3.4 方法的定义__形参__实参__返回值__语句块

3.5方法的重载

第四章   4.3类

       属性、方法

举例：

/**
 * 测试类
 * @author 15386
 *
 */
public class Student {
	//属性
	int id;
	String name;
	int age;
	//方法，实现的功能
	void study() {
		System.out.println("我在认真学习！");
	}
	
	void play() {
		System.out.println("我在玩游戏！");
	}
	//调用方法，程序执行的入口，必须要有
	public static void main(String[] args) {
		Student stu=new Student();//建好了对象
		stu.play();
	}

}

Java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area

构造方法 要点：

1. 通过new关键字调用
2. 构造器虽然有返回值，但是不能定义返回值类型（返回值的类型肯定是本类），不能在构造器里使用return返回某个值
3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加
4. 构造器的方法名必须和类名一致

4.13  Java的包机制

     package

第五章     三大特征

        ----继承

1. Java中只有单继承
2. 子类继承父类，可以得到父亲的全部属性和方法
3. 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object

instanceof用来判断 前面一个类属不属于后边的类型

方法的重写override：覆盖原来的

super父类对象引用

package cn.sxt.oo;

public class TestSuper01 {
	public static void main(String[] args) {
		new ChildClass().f();
	}
}
class FatherClass{
	public int value;
	
	public void f() {
		value=100;
		System.out.println("FatherClass.value="+value);
	}
}

class ChildClass extends FatherClass{
	public int value;
	
	public void f() {
		super.f();
		value=200;
		System.out.println("ChildClass.value="+value);
		System.out.println(value);
		System.out.println(super.value);//调用父类对象的成员变量
			
		}
	}

封装的使用

1. 一般使用private访问权限
2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取 *** 作（注意：Boolean变量的get方法是is开头）
3. 一些只用于本类的辅助方法可以用private修饰，希望其他类调用的方法用public修饰。

多态：

要点：

1. 多态是方法的多态，不是属性的多态（多态与属性无关）
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

第七章
1.数组的概念
数组是相同类型数据的有序集合，每一个元素可通过下标来访问

特点：1.长度是确定的

           2.元素必须是相同类型

           3.数据类型可以是任何数据类型 

数组是对象

数组的声明：type[] name或type name[];

2.数组的初始化：静态初始化、动态初始化、默认初始化
 

public class test01 {
  public static void main(String[] args) {
   //静态初始化
   int[] a= {2,3,5};
   user[] b= {
         new user("张三",10),
         new user("李四",20),
         new user("王五",30),
             };
   //默认初始化
   int[] c=new int [3];//默认给元素赋值
   //动态初始化
   int [] d=new int[2];
   d[0]=3;
   d[1]=9;
   
  }
}
class user{
 public String name;
 public int age;
 user(String name,int age){
  this.name=name;
  this.age=age;
 }
}

3.数组的遍历
 遍历：初始和读取

foreach循环，用于读取数组元素的值，不能修改元素的值

package cn.dd;
 
public class test03 {
  public static void main(String[] args) {
    int[]a=new int[4];
    for(int i=0;i

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/langs/876672.html