Java周记(第一周)

根据b站上的网课和Java的相关资料，整理了Java的相关知识

目录

第一章

1.注释

2.标识符规则

3.关键字/保留字

4. 变量

5.常量

6.基本数据类型

整型变量和整型常量

浮点型变量和常量

字符型变量和常量

Boolean类型变量和常量

 7.类型转换 

 自动类型转换

强制类型转换

8.运算符

算术运算符

赋值运算符以及扩展赋值运算符

关系运算符

逻辑运算符

位运算符

 字符串连接符

条件运算符(三目运算符）

9.使用Scanner获取键盘的输入 

第二章 

1.控制语句

选择结构（如果....,则....)

循环结构（如果....,则继续....)

2.break和continue语句 

3.方法

4.方法的重载 

 5.递归算法

第三章

1.对象和类

2.典型的类

3.内存分析

1.栈

2.堆

 3.方法区

4.构造方法

5.垃圾回收机制

6.this的本质

7.static关键字

8.参数传值机制

9.Java包机制

10.import导入类

第四章

 1.继承

1.继承的基本知识

2.方法的重写

3.Object类

 2.封装

3.多态 

         4.抽象类和抽象方法 

         5.接口

        6. 内部类

        7.String类 

第七章

1.数组的概念

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

3.数组的遍历

---

第一章

1.注释

• 单行注释：//  后面的单行均为注释
• 多行注释：/* */  两个*之间为注释（不能嵌套）
• 文档注释：/** */  第二、三个*之间为注释，注释中包含一些说明性的文字及JavaDoc标签

2.标识符规则

• 作用：用来给变量、类、方法、包进行命名
• 规则：

标识符必须以字母、下划线“-”、美元符号“$”开头

标识符其他部分可以是字母、下划线“-”、美元符号“$”和数字的任意组合

Java大小写敏感，但长度无限制

标识符不能是关键字

• 规范：

类名的标识符尽量大写（也可以不大写）

表示方法和变量的标识符第一个单词小写，第二个单词大写（如eatFood（））

变量可以是汉字，但不建议使用（int 年龄=18；//是可以的)

3.关键字/保留字

abstract	assert	boolean	break	byte	case	catch	char	class
continue	default	do	double	else	extends	final	finally	float
goto	if	implements	import	instanceof	int	interface	long	native
null	package	private	protected	public	return	short	static	strictfp
switch	synchronized	this	throw	throws	transient	try	void	volatil
const	for	new	super

4. 变量

• 本质：

代表一个“可操作的存储空间”，位置确定，但内容不确定。可通过访问变量名来访问空间，从而操作空间。

• 变量的声明

每个变量必须声明数据类型，决定了变量的存储空间。

变量要素包括变量名、变量名称、作用域。（如 int a;)

     注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型

变量名必须是合法的标识符

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

• 变量的分类

局部变量：在方法或语句块中定义的变量。从声明位置开始到方法或语句执行完毕结束（必须要初始化）

成员变量：方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。（可手动赋值，也会会自动初始化）

静态变量：使用static定义。从属于类，生命周期（三个中活得最长）伴随类始终，从类的加载到卸载。

5.常量

通常指一个固定的值，如1，2，3，a，b，c，true，false

在Java中，主要用关键字final定义常量，该常量被称为符号常量，一旦被初始化，就不能再改变值

6.基本数据类型

数值型（整型，浮点型）：byte（1字节），short（2字节），int （4字节），long（8字节），float（4字节），double（8字节）

字符型：char（2字节）

布尔型：boolean（1位）

• 整型变量和整型常量

变量：byte（1字节）【-128—127】，short（2字节）【-32768—32767】，int （4字节）【-2147483648—2147483647】，long（8字节）

常量：十进制数：如2，3，4，60，700

           八进制数：“0”开头，如015

          十六进制数：“0x”开头，如0x15

           二进制数：“0b”开头，如0b01110011

        注意：Java的整型常量默认为int型，声明long类型通常加“l”或“L”，如555555L

• 浮点型变量和常量

变量：float（4字节）【精确到7位有效数字】，double（8字节）

常量：十进制：3.14、4.56

           科学计数法:314e2、314e-2

注意：默认常量为double型，声明float类型要加“f”或“F”，如3.14f

浮点型是不精确的，不要用于比较！！

如果要比较，可使用Java.math下的两个类：BigInteger实现任意精度的整数运算，GigDecimal实现任意精度的浮点运算。

      例如： GigDecimal a=GigDecimal.valueOf(1.0/10.0);//会得到精确的结果

• 字符型变量和常量

       变量：char（2字节）

用来表示在Unicode编码表中的字符

转义字符：

转义字符	含义
\b	退格
\n	换行
\r	回车
\t	制表符
\ "	双引号
\ '	单引号
\\	反斜杠

注意：String类型是字符序列

• Boolean类型变量和常量

 常量：true、false

注意：与C不同，不能用0或非0的整数替代

在if中，if（man）相当于man==true

 7.类型转换 

•  自动类型转换

是由容量小的数据类型自动转换为数据量大的数据类型（即表示范围小的向范围大的转换）

public class test{
   public static void main(String[] args){
      int a=324;
      long b=a;
      double d=a;//都可以自动转换
      System.out.println(b);//输出324
      System.out.println(d);//输出324.0
      //a=b;不能做自动转换
      //long e=3.23;不能转换
     float f=234323L;//可以自动转换
     System.out.println(f);//输出234323.0
     //byte b2=1230;超过表示范围，不能转换
  }
}

• 强制类型转换

 语法格式：（数据类型）变量

public class test{
  public static void main(String[] args){
    double x=3.14;
    int y=(int)x;
    char c='a';
    int d=c+1;
    System.out.println(y);//输出3
    System.out.println(d);//输出98
    System.out.println((char)d);//输出b
  }
}

要注意数据溢出的情况 

8.运算符

 算数运算符（+ - * / % ++  --)、赋值运算符(=)、扩展运算符(+=  -=  *=  /=)、关系运算符(> < >= <= == != )、逻辑运算符(&&  ||  !  ^)、位运算符(&  |  ^  ~  >> <<  >>>)、条件运算符(? :)、字符串连接符(+)

• 算术运算符

二元运算符： 

有左右两个操作数的运算符为二元运算符

    二元运算符做整数运算：有一个为Long，结果也为Long；没有Long时，结果为int

    二元运算符做浮点运算：有一个为double，结果也为double；两个操作数全为float,结果为float

    二元运算符做取余运算：操作数可以是整型和浮点型 ，结果为余数

一元运算符：++ ：自增。++a：先自增后赋值；a++：先赋值后自增

                       -- ：自减。--a：先自减后赋值；a--：先赋值后自减

              如：a=10；++a；b=a；结果b=11,a=11

                     a=10；a++；b=a；结果b=11,a=10

• 赋值运算符以及扩展赋值运算符

“=”为赋值运算符：a=3 是将3赋给了a；

扩展运算符：+= ,-= ,*= ,/=      如：a+=b相当于a=a+b;其余类似；a*=b+3相当于a=a*(b+3)

• 关系运算符

 > ，< ，>= ，<= ，== （等于），!=（不等于）

前四个仅针对数值运算和char运算，后两个都适用

• 逻辑运算符

操作数和结果为Boolean 

运算符		说明
逻辑与	&	左右操作数为true，结果才为true，负责为false
逻辑或	|	左右操作数有一个为true，结果就为true
短路与	&&	只要有一个为false，直接返回false
短路或	||	只要有一个为true，直接返回true
逻辑非	！	!false为true，!true为false
逻辑异或	^	左右操作数相同为false，不同为true

注意：&，|，^同时也是位运算符

短路运算符从左到右计算，如果左边的值能确定结果，则直接返回结果，提高效率

• 位运算符

 指的是二进制的运算

位运算符	说明
~	取反
&	按位与
|	按位或
^	按位异或
<<	左移运算符，相当于乘二
>>	右移运算符，相当于除二

•  字符串连接符

“+” 

public class test {
		  public static void main(String[] args) {
		     String a="3";
		     int b=4;
		     int c=5;
		     System.out.println(a+b);//输出34
		     System.out.println(a+c);//输出35
             System.out.println(a+b+c);//输出345

}
}

• 条件运算符(三目运算符）

 语法格式：x ？y：z（其中x为Boolean类型，若x为true，则返回y，否则将返回z）

public class test{
  public static void main(String[]args){
     int score =80;
     String type=score>60?"及格":"不及格";
     System.out.println(type);//输出及格

  }
}

运算符优先级

逻辑非>逻辑与>逻辑或

可使用小括号来组织更方便
 

9.使用Scanner获取键盘的输入 

import java.util.Scanner;
public class test{
  public static main(String[] args){
    Scanner scanner=new Scanner(System.in);
    System.out.println("请输入你的名字");
    String name=scanner.nextLine();
    System.out.println("请输入你的爱好");
    String favor=scanner.nextLine();
    System.out.println("请输入你的年龄");
    String age=scanner.nextInt();
    System.out.println(name);
    System.out.println(age);
    System.out.println(favor);
  }
}

第二章 

1.控制语句

用来控制程序中各语句执行顺序的语句。有顺序结构，选择结构，循环结构

• 选择结构（如果....,则....)

 if单选择结构        if（布尔表达式）{语句块}

public class test{
  public static void main(String[] args){
	   double d=Math.random();//生成0至1之间的随机数
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//生成1至6之间的随机数
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("小");}
  }
}

if-else 双选择结构

public class test {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//生成1至6之间的随机数
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("小");}
	   else
		   {System.out.println("大");}
  }
}

if-else if-else 多选择结构

public class test {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//生成1至6之间的随机数
	   System.out.println(a);
	   if(a<=3)
		   {System.out.println("小");}
	   else if(a==4)
		   {System.out.println("a=4");}
	   else//a>4的情况
		   {System.out.println("大");}
  }
}

switch 结构（用来判断多值的情况）

switch(表达式）

{

case 值1：语句1；break；//值是整数或字符串，break表示结束语句

case 值2：语句2；break；

.......................................；

case 值n：语句n；break；

default ：语句；break；

}

public class test01 {
   public static void main(String[]args){
	   double d=Math.random();
	   System.out.println(d);
	   int a=(int)(6*Math.random()+1);//生成1至6之间的随机数
	   System.out.println(a);
	   switch(a)
	   {
	   case 1:System.out.println("a=1");break;
	   case 2:System.out.println("a=2");break;
	   case 3:System.out.println("a=3");break;
	   case 4:System.out.println("a=4");break;
	   case 5:System.out.println("a=5");break;
	   case 6:System.out.println("a=6");break;
	   default:System.out.println("不在1至6的范围");break;
	   }
  }
}

• 循环结构（如果....,则继续....)

 while循环  先循环后判断

语法：while（布尔表达式）

{

循环体

}

public class test01 {
   public static void main(String[]args){
	   int a=0;
	   int sum=0;
	   while(a<=50)
	   {
		   sum+=a;
		   a++;
	   }
	   System.out.println(sum);//计算1+2+3+3+....+50，输出1275
  }
}

do while 循环是先执行后判断

public class test01 {
   public static void main(String[]args){
	   //计算1+2+3+3+....+50
	   int a=0;
	   int sum=0;
	   do
	   {
		   sum+=a;
		   a++;
	   }while(a<=50);
	   System.out.println(sum);输出1275
  }
}

for循环

public class test01 {
   public static void main(String[]args){
	   //计算1+2+3+3+....+50
	   int sum=0;
	   for(int i=0;i<=50;i++)
	   {
		   sum+=i;
	   }
	   System.out.println(sum);输出1275
      
  }
}

 嵌套循环

在一个循环里再套另一个循环

public class test01 {
   public static void main(String[]args){
	   //计算1+2+3+3+....+50
	   int sum=0;
	   for(int i=1;i<=5;i++)
	   {
		   for(int j=1;j<=5;j++)
		   {
			   System.out.print(" "+j);
		   }
		   System.out.print('\n');
	   }
	   
  }
}

输出结果为： 

 例题：输出九九乘法表

public class test {
   public static void main(String[]args){
	   int sum=0;
	   for(int i=1;i<=9;i++)
	   {
		   for(int j=1;j<=9;j++)
		   {
			   if(j<=i)
			   {
				   sum=j*i;
				   System.out.print(j+"*"+i+"="+sum+" ");
			   }
		   }
		   System.out.println();
	   }
  }
}

输出结果为： 

2.break和continue语句 

 break用于强行退出循环，不执行循环中剩余的语句

continue指终止本次循环，进行下次循环

带标签的break和continue语句   

 标签是指后面跟一个冒号的标识符，如“label：”

作用：我们希望在其中一个循环中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，若随标签使用，他们就会终端存在标签的地方。

public class test {
  public static void main(String[] args) {
	  outer:for(int i=101;i<150;i++)
	  {
		  for(int j=2;j<i/2;j++)
		  {
			  if(i%j==0)
			  {
				  continue outer;//直接返回到i所在的外部循环
			  }
		  }
		  System.out.print(i+" ");//输出从101至150之间的质数
	  }
  }
}

3.方法

语句块：块决定了局部变量的作用域，块中的程序代码，作为一个整体，是要被一起执行的。

方法：是一段用来完成特定功能的代码片段，类似于其他语言的函数。

1. 方法声明格式：[修饰符1，修饰符2，.....]  返回值类型     方法名（形参列表）{Java语句；........}

2. 方法调用格式：对象名.方法名（实参列表）

  形参：在方法声明时用于接收外界传入的数据

  实参：调用方法时实际传给方法的数据

  返回值：方法在执行完毕后返回调用它的环境的数据

  返回值类型：事先约定的返回值的数据类型，如果没有返回值，返回值类型必须为void

public class test02 {
  public static void main(String[] args) {
	  test02 tm=new test02();
	  tm.print();
	  int c=tm.add(3, 40, 5)+20;
	  System.out.println(c);
	  tm.add1(30, 40);
	  
  }
  void print() {
	  System.out.println("学习使我快乐！");
	  System.out.println("学习使我充实！");
  }
  int add(int a,int b,int c)
  {
	  int sum=a+b+c;
	  System.out.println(sum);
	  return sum;//return结束程序的运行，也返回sum
  }
  void add1(int a1,int b1) {
	  int num=a1+b1;
	  System.out.println(num);
  }
}

注意：

  1.实参的数目、数据类型和次序必须和所调用的方法的形参列表匹配

  2.return语句终止方法的运行并指定要返回的数据

  3.Java中进行方法调用中传递参数时，遵循值传递的原则（传递的都是数据的副本）

  4.基本数据类型传递的是该数据的copy值

  5.引用类型传递的是该对象引用的copy值，但指向的是同一个对象    

4.方法的重载 

名称相同，但是完全不同（形参类型、形参个数、形参顺序不同）的方法

 注意：返回值不同，参数名称不同都不会构成方法的重载

 5.递归算法

 基本思想：自己调用自己

比如下面代码会输出无数个a

public class test02 {
  public static void main(String[] args) {
	  a();
	  
  }
  static void a()
  {
	  System.out.println("a");
	  a();
  }
  
}

递归结构包括：递归头（递归结束的条件）和递归体（什么时候调用自身方法）

如上代码只能输出5个a

例题：

求阶乘 10！

public class test02 {
  public static void main(String[] args) {
	  System.out.println(a(10));
	  
  }

  static long a(int n)
  {
	  if(n==1)
	  {
		  return 1;
	  }
	  else return n*a(n-1);
  }
  
}

第三章

1.对象和类

 类为class，对象是object，instance

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 s=new student();
		s.play();
	}
}

2.典型的类

public class student {

	int id;
	String name;
	int age;
	computer c;
	void study() {
		System.out.println("我在认真学习！"+"使用"+c.brand);
		
	}
	void play() {
		System.out.println("我在玩游戏！");
	}
	//程序执行的入口，必须要有
	public static void main(String[] args) {
		student s=new student();//创建一个对象
		s.name="张三";
		s.age=18;
		s.id=123456;
		computer c1=new computer();
		c1.brand="联想";
		s.c=c1;
		s.study();
		s.play();
	}
}
class computer{
	String brand;
	
}

3.内存分析

分三个区域：栈，堆，方法区

1.栈

栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口）

JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量）

栈属于线程私有，不能实现线程之间的共享

栈的存储特性是先进后出、后进先出

栈是由系统自动分配，速度快，栈是一个连续的内存空间

2.堆

堆用于存储创建好的对象和数组（数组也是对象）

JVM只有一个堆，被所有线程共享

堆是一个不连续的内存空间，分配灵活，速度慢

 3.方法区

JVM只有一个方法区，被所有线程共享

方法区实际也是堆，只是用于存储类、常量相关的信息

用来存放程序中永远不变或唯一的内容

 由上一个程序可得：

4.构造方法

用于对象的初始化

要点：1.通过new关键字使用

           2.构造器虽然有返回值，但是不能定义返回值类型（返回值类型必须是本类），不能再构造器里使用return某个值

           3.如果我们没有定义构造器，编译器会自动定义一个无参的构造函数，如果已定义，编译器就不会自动添加

           4.构造器的方法名必须和类名一致

class point {
  double x,y;
  public point(double m_x,double m_y) {
	  x=m_x;
	  y=m_y;
  }
  public double getdistance(point p) {
	  return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));//计算两点间的距离
  }
  
}
class test{
	public static void main(String[] args) {
		point p=new point(3.0,4.0);
		point p1=new point(0.0,0.0);
		System.out.println(p.getdistance(p1));
	}
}

构造方法的重载

5.垃圾回收机制

作用：1.发现无用的对象

           2.回收无用对象占用的内存空间

相关算法：

        1.引用计数法

堆中每个对象都有一个引用计数，被引用一次，计数加1，被引用变量值变为ULL，则计数减1，直到计数为0，则表示无用对象。

        2.引用可达法

 程序把所有的引用关系看作一张图，从一节点GC ROOT开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕后，剩余的节点则被认为是没有被引用的节点，即无用的节点。

6.this的本质

本质就是“创建好的对象的地址”，由于在构造方法调用前，对象已经创建，因此，在构造方法中也可以是使用this代表“当前对象”。

public class testthis {
  int a,b,c;
   testthis(int a,int b){
	   this.a=a;
	   this.b=b;
   }
   testthis(int a,int b,int c){
	   this(a,b);//调用构造方法
	   this.c=c;
   }
   void sing() {
	 System.out.println("唱歌");
   }
   void eat() {
	   this.sing();
	   System.out.println("回家吃饭！");
   }
   public static void main(String[] args) {
	   testthis s=new testthis(2,3);
	   System.out.println(s.a);
	   System.out.println(s.b);
	   System.out.println(s.c);
	   s.eat();
   }
}

this 不能用于static方法中

7.static关键字

在类中，用static声明的成员变量为静态成员变量，也称为类变量，类变量的生命周期和类相同，在整个应用程序执行期间都有效。

static修饰的成员变量和方法从属于类，普通变量和方法从属于对象。

被类的所有对象所共享

可以通过类名和对象名调用

static的访问：

非静态成员方法能访问静态和非静态的成员方法和变量

静态成员方法只能访问静态成员变量和方法

静态初始化块

例如：static {

System.out.println("输出");

}

8.参数传值机制

基本数据类型值传递传的是值的副本

引用类型的传值是传的副本，但是引用指向的是地址，副本和原参都指向了一个地址，所以，改变副本指向的地址的值，也就是改变了原参数指向对象的值也改变了。

9.Java包机制

包机制是Java中管理类的重要手段，开发中，我们会遇到大量同名的类，通过包我们很容易对解决类重名的问题，也可以实现对类的有效管理，包对于类，相当于文件夹对于文件的作用。

1.通常是类的第一句非注释性语句

2.包名：域名倒着写即可，再加上模块名，便于内部管理类。

10.import导入类

Java会默认导入Java.lang包下的所有的类，因此我们可以直接调用这些类

如果导入两个同名类，只能用包类+类名来显示调用的相关类

第四章

面向对象的三大特征：继承，封装，多态

 1.继承

1.继承的基本知识

public class testexend {
   public static void main(String[] args) {
	   student s= new student();
	   s.name="张三";
	   s.age=20;
	   s.school="大学";
   }
}
class person{
	String name;
	int age;
	public void rest() {
		System.out.println("休息一小时！");
	}
}
class student extends person{//student继承了person类的成员
	String school;
	public void study() {
		System.out.println("学习一小时！");
	}
	
}

要点：1.父类也叫做超类、基类、派生类

           2.Java中只有单继承，没有多继承

           3.Java类中没有多继承，接口有多继承

           4.子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得能直接访问（比如私有的）

           5.如果定义一个类时，没有调用extends，则他的父类是java.lang.Object

 instanceof是二元运算符，左边是对象，右边是类，若对象是右边类或子类所创建的对象时，返回值为true。

public class testexend {
   public static void main(String[] args) {
	   student s= new student();
	   s.name="张三";
	   s.age=20;
	   s.school="大学";
	   s.rest();
	   s.study();
	   System.out.println(s instanceof student);
	   System.out.println(s instanceof person);
	   System.out.println(s instanceof Object);
   }
}
class person{
	String name;
	int age;
	public void rest() {
		System.out.println("休息一小时！");
	}
}
class student extends person{
	String school;
	public void study() {
		System.out.println("学习一小时！");
	}
	
}

2.方法的重写

子类通过重写父类的方法，可以用自身的行为替换父类的行为。

要点：1.“==”：方法名、参数列表相同

           2.“<=”：返回值类型和声明异常类型，子类小于等于父类

           3.“>=”：访问权限，子类大于等于父类

public class testoverride {
  public static void main(String[]args) {
	  son s=new son();
	  s.work();//覆盖父类的work方法
  }
}
class father{
	public void work() {
		System.out.println("工作一会");
	}
	public father play() {
		return new father();
	}
}
class son extends father{
	public void work() {
		System.out.println("不要工作了");
	}
	public son play() {
		return new son();//返回值类型小于等于父类的类型
	}
}

3.Object类

toString方法：源代码为：

public String toString(){
   return getClass().getName()+"@"+Tnteger.toHexString(hashCode());
}

 重写：

public class testobject {
  public static void main(String[] args) {
	 testobject to=new testobject();
	 System.out.println(to.toString());//输出类似：testobject@515f550a
	 person p=new person();
	 p.name="张三";
	 p.age=19;
	 System.out.println(p.toString());
  }
  public String toString() {
	  return "重写";
  }
}
class person{
	String name;
	int age;
	public String toString() {
		return name+"年龄:"+age;
	}
}

equals方法：源代码为：

public boolean equals(Object obj){
   return (this == obj);
}

public class testequals {
   public static void main(String[] args) {
	   person t1 = new person(67890,"王五");
	   person t2 = new person(12345,"李四");
	   System.out.println(t1==t2);
	   System.out.println(t1.equals(t2));
   }
   
}
class person{
	int id;
	String name;
	public person(int id,String name)
	{
		this.id=id;
		this.name=name;
	}
	
}

重写： 

import java.util.Objects;

public class testequals {
   public static void main(String[] args) {
	   person t1 = new person(12345,"王五");
	   person t2 = new person(12345,"李四");
	   System.out.println(t1==t2);
	   System.out.println(t1.equals(t2));
   }
   
}
class person{
	int id;
	String name;
	public person(int id,String name)
	{
		this.id=id;
		this.name=name;
	}
	@Override
	public int hashCode() {
		return Objects.hash(id);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		person other = (person) obj;
		return id == other.id;
	}
	
}

右键——source——如图，可自动根据选择生成重写

 

 super是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法或属性

public class testsuper {
  public static void main(String[] args) {
	  //father f=new father();
	  son s=new son();
	  s.f();
  }
}
class father{
	public int num;
	public void f() {
		num=100;
		System.out.println("father.num="+num);
	}
}
class son extends father{
	public int num;
	public void f() {
	num=200;
	System.out.println(num);//输出200
	super.f();//调用父类对象的普通方法，输出father.num=100
	System.out.println(super.num);//调用父类对象的普通方法，输出100
	System.out.println("son.num="+num);//输出son.num=200
	}
}

继承树追溯

构造方法的第一句总是：super（....）来调用父类的构造方法，所以，流程为：先追溯到Object，然后向下执行类的初始化块和构造方法，知道当前子类为止。

 2.封装

 访问控制符

  

修饰符	同一个类	同一个包	子类	所有类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

private：表示私有，只能自己访问

default：表示没有修饰符修饰，只有同一个包的类能访问

protected：表示可以被同一个包的类以及其他包的子类访问

public：可以被该项目的所有包中的所有类访问

 要点：1.类的属性一般都私有

            2.提供相应的set、get方法来访问相关属性

            3.一些只适用于本类的辅助性方法可以用private来修饰

3.多态 

指同一个方法调用，由于对象不同可能会有不同的行为。

 要点：1.多态是方法的多态，不是属性的多态（多态与属性无关）

            2.多态存在的三个必要条件：继承、方法重写、父类引用指向子类对象

            3.父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

public class testpolyme {
  public static void main(String[] args) {
	  animalaa(new animal());
	  animalaa(new dog());
	  animalaa(new cat());
	  
  }
  static void animalaa(animal a) {
	  a.shout();
  }
}
class animal{
	public void shout() {
		System.out.println("叫了一声");
	}
}
class dog extends animal{
	public void shout() {
		System.out.println("汪汪汪");
	}
}
class cat extends animal{
	public void shout() {
		System.out.println("喵喵喵");
	}
}

对象的转型

animal d=new dog();将dog转换为animal类，现在d为animal类

dog d2=（dog）d；将animal类的dog转换为dog类

finall关键字 

1.修饰变量：被它修饰的变量不能改变，一旦赋了值，就不能再重新赋值

2.修饰方法：该方法不可被子类重写，但是可以被重载

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<a.length;i++)
	   {
		   a[i]=2*i;
	   }
	   for(int i=0;i<a.length;i++)
	   {
		   System.out.println(a[i]);
	   }
	   //foreach循环，用于读取数组元素的值，不能修改元素的值
	   for(int m:a) {
		   System.out.println(m);
	   }
	   
	 }
}