JAVA学习Day20190606-CSDN博客

本文链接：https://blog.csdn.net/Thiner_D/article/details/91337704

JAVA学习Day20190606

基础部分
JAVASE部分
附上代码

基础部分

1.基本数据类型
byte short int long float double char boolean
8 16 32 64 32 64 16 8
内存中都是二进制补码的形式
2.引用类型：除去基本数据类型均为引用类型
数组
类
接口
3.循环，判断
4.数组：长度不可改变
扩容 Arrays.copyOf System.arraycopy
排序 array_sort
选择排序、冒泡排序、插入排序（快速排序，归并排序）
递归算法：自己调用自己
核心：有结束方法的条件
5. 面型对象：封装、继承、多态
* 类、对象
* 类的成员：属性、方法、构造器（构造方法）
* static ->属于类的
*
* 封装：成员变量私有化，并且提供外部可以访问的get/set方法,属性
*
* 方法的重载：方法名一样，参数列表不同
* 方法的返回值无关
*
* this:当前对象，调用自己的属性，自己的方法，自己的构造器
* super:父类对象
*
* 继承：子类继承父类，就会继承父类所有非私有的属性和方法
* 子类也可有自己独特的属性和方法—>子类一定比父类更强大
* 父类的作用：公共部分的提取
* super —>子类会默认调用父类的无参构造器
*
* 多态：重写
* 重写：增强、抽象方法
* 向上造型：只能调用父类有的属性和方法，有统一性的意义
* 最终调用的是子类重写的方法
* 但若子类没有重写，才调用父类定义的方法
* 如果要调用子类中特有的属性和方法，必须强制类型转换
*

JAVASE部分

JavaSE ：Java基础 JavaEE JavaME
1.JDK：目录结构
* C:\Program Files\Java\jdk1.8.0_162\bin
* bin - 工具
* lib - xx.jar -> Java字节码文件打包而成
* jre - JRE
2.JRE：Java运行环境
* 工具 + JRE
* JVM + libraries [lib] [rt.jar 核心]
* 类库–> Java代码执行时要用的类
3.JVM：Java虚拟机
* 执行Java代码
*
4.Java代码运行原理
*
5.API：application programming interface - 应用程序接口
* 已经写好的代码
*
6.学习目标：
* 类 --> 创建对象（构造器）
* --> 调用属性、方法 - 功能
* 接口 --> 实现类
* --> 自带实现类
*
*
7.Javadoc：将文档注导出形成帮助文档
*
*
8. java.lang --> 默认软件包
* Object----> 所有类的父类
* String
* System
* Math
* StringBuilder
* StringBuffer
* Thread
9. java.util -->工具包
* Arrays
* Scanner
* Data
* Calendar
* 集合：List/Set/Map…
10. java.io -->输入输出
* 文件相关
11. java.sql --> 连接数据库
*
12. java.net --> 网络编程
*
13. java.text --> 格式相关
*
*
*
14.Object：所有类的根 - 父类 - 基类
* API：11个
* wait *3
* notify()/notifyAll() —> 线程相关
*
* ---->要重写的方法，有默认的实现方式
* toSrting() --> 对象的字符串打印方式
* 默认：完整类名@哈希值[内存地址]16进制字符串
* 重写toString：目的是为了打印对象内容
*
* equals() —> 判断两个对象内容是否一致
* 默认：两个对象 == 实现
* hashCode() -->获得对象对应的哈希值
*
*
*
* getClass() --> 每一个类加载进来都会有一个对应的Class对象
* 一个类只加载一次
* 类加载时执行的代码：
* 类加载时需要将静态属性和静态代码块已经静态方法全部价值
* static —> 静态属于类
*
* clone() —> 对象克隆/复制，浅克隆
* 浅克隆：复制引用，最终两个引用指向同一个对象
* 深克隆：复制对象，最终两个引用分别指向两个对象
* 如果调用clone方法，必要实现cloneable接口，cloneable接口是空的，作用就是为了标示类是可克隆的
* 克隆图
*
* finalize() —>垃圾回收调用的方法,默认空实现，测试需要重写
* 堆：对象，不会主动释放，内存空间持续占用，可用内存越来越小---->内存泄露
* Java原则上来说不存在内存泄露，但短时间内非法大量创建对象会导致内存泄露
* GC （garbage collection ）自动定期清除内存垃圾
* 手动清理垃圾 System.gc()
* 栈：临时变量/局部变量,使用完自动释放
* 对象内存图
*
15.JUnit 单元测试 —> 取代主方法
* 主方法测试 - System.out.println() -> 打桩
* debug测试，也叫断点测试 --> 专业（可以观察每一步的变化）
*
*
16.final：最终的
* 修饰类：不能被继承 String
* 修饰方法：不能被重写
* 修饰属性：不能被修改 --> 常量，必须初始化
17.native：调用本地C语言代码

附上代码

Person.java

 package zzxx.Day0606;

 /*
  * 静态属于类
  * 非静态属于对象
  */

public class Person {
private String name;
private int age;
private char sex;

static double money = staticMethod();

static {//静态代码块
	//类的初始化
	System.out.println("--静态代码块--");
}

//静态方法  的加载只是单纯加载--> 方法区中，不是调用
public static double staticMethod() {
	//给类调用
	System.out.println("--静态方法--");
	return 1000;
}

{
	System.out.println("代码块");
}


public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
public char getSex() {
	return sex;
}
public void setSex(char sex) {
	this.sex = sex;
}


public Person() {
	super();
	// TODO Auto-generated constructor stub
}

//全参构造器
public Person(String name, int age, char sex) {
	super();
	this.name = name;
	this.age = age;
	this.sex = sex;
}

public void finalize() {
	System.out.println("要走了");
}


//IDE :集成开发工具 Eclipse  IDEA
@Override
public String toString() {
	return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
@Override
public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + age;
	result = prime * result + ((name == null) ? 0 : name.hashCode());
	result = prime * result + sex;
	return result;
}
@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;
	if (age != other.age)
		return false;
	if (name == null) {
		if (other.name != null)
			return false;
	} else if (!name.equals(other.name))
		return false;
	if (sex != other.sex)
		return false;
	return true;
}



//重写规则随意，自定义打印内容
//	public String toString() {
//		return this.name +","+this.age+","+this.sex;
//	}
//	

//重写规则，自己定义
//	public boolean equals(Object obj) {
//		//Person p1 =new Person("张三",23,'男');
//		//Person p2 =new Person("张三",23,'男');
//		
//		if(this==obj) {//this和obj指向同一个对象
//			return true;
//		}
//		//obj不是person类型，直接返回false
//		if(!(obj instanceof Person)) {
//			return false;
//		}
//		Person p2=(Person)obj;
//		//name是字符串类型，引用类型[对象]，对象的比较都是用equals
//		if(this.name.equals(p2.name)&&this.age==p2.age&&this.sex==p2.sex) {
//			return true;
//		}
//		return false;
//	}
}

animal.java

package zzxx.Day0606;
/*
* 定义一个类
*/
public class animal extends Object {
//成员变量--私有的--封装性
private String name;
private  int  age;


{
	//代码块---等同于构造器,在所有构造器调用之前执行
	System.out.println("代码块");
	
}


//默认添加无参构造器--->没有定义构造器的时候
//构造器的目的：为了给属性初始化
public animal() {
	name = "xiaoqiang";
	age = 0;
}

//有参构造器
public animal(String name, int age) {
	//this();//自己的无参构造器---->手动
	super();//调用父类的构造器--->默认
	this.name = name;
	this.age = age;
	this.eat();//调用自己的方法
}

//成员方法
public void eat() {
	System.out.println("动物 吃");
}
public int getAge() {
	return age;
}

public void setAge(int age) {
	this.age = age;
}

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}


}

APIDOC.java

package zzxx.Day0606;
/**
 * 
 * 这是一个帮助文档的测试类
 * @author Administrator
 * @since 从1.0版本以后生效
 * @version 1.8
 * @see zzxx.Day0606.animal
 * 		另外参考什么类
 *
 */
public class APIDOC {
//单行注释
/*
 * 多行注释
 */
/**
 * 文档注释
 * 这是一个静态常量字段，表示宽度
 */

public static final int WIDTH = 200;

/**
 * 这是一个无参构造器，虽然没啥用，但可以拿来测试
 * 
 */
public APIDOC() {
	
}
/**
 * 
 * 
 * @param a 对参数a的解释
 * @param b 对参数b的解释
 * @return 对返回值的注释
 */
public int test01(int a ,int b) {
	return 0;
}

}

ObjectDemo.java

package zzxx.Day0606;

import org.junit.Test;

public class ObjectDemo {

//JVM 可以读取的，注解
@Test
public void test01() {
	Person p1 =new Person("张三",23,'男');
	Person p2 =new Person("张三",23,'男');
	//p1和p2是不是同一个对象
	System.out.println(p1==p2);//false
//		
//		//p1和p2是同一个对象
//		p2=p1;//引用的赋值
//		
//		p2.setName("李四");
//		System.out.println(p1.getName());
//		
	//c1中包含Person类的所有信息
	Class c1 = p1.getClass();
	Class c2 = p2.getClass();
	
	System.out.println(c1==c2);  //true
	
		
}
@Test
public void test02() {
		System.out.println("start");
		for(int i=0;i<10;i++) {
			System.out.println(i);
		}
		System.out.println("end");
}

@Test
public void test03() {
		System.out.println("test03 "+true);
}
@Test
public void test04() {
	Person p1=new Person();
	p1=null;//p1不指向任何对象
	//手动清理垃圾
	System.gc();

		
}

@Test
public void test05() {
	Person p1 =new Person("张三",23,'男');
	Person p2 =new Person(); // null , 0 ,0
	
	//打印对象，实际上就是调用对象的toString方法
	System.out.println(p1);
	//System.out.println(p1.toString());
	System.out.println(p2);
	
}

@Test
public void test06() {
	//从主观上判断p1和p2是同一个人
	Person p1 =new Person("张三",23,'男');
	Person p2 =new Person("张三",23,'男');
	
	System.out.println(p1==p2);
	//业务规定p1和p2内容完全一致，可以判断是同一个人，equals返回值类型为boolean
	System.out.println(p1.equals(p2));
}

}