JAVA基础工作内容学习

JAVA Study

• 编译环境
• String
• • String基础知识
  • StringBuilder基础知识
  • String和StringBuilder的互相转换
• 集合
• • ArrayList
• 继承
• • this和super
  • 继承访问特点
  • • 构造方法的访问特点
    • 成员方法的访问特点
  • 方法重写
  • JAVA中继承
• 包
• • 修饰符
  • • 权限修饰符
    • 状态修饰符
• 多态

编译环境

1、JVM: Java Virtual Machine java虚拟机，保证跨平台使用（比如，在LINUX系统安装与之对应的JVM）

System.exit(0);//JVM退出

2、JRE: Java Runtime Environment 是java程序运行环境，包含JVM和运行时所需要的核心类库。
3、JDK：Java Development Kit 是java程序的开发工具包，包含JRE和开发人员使用的工具（如：javac.exe和java.exe）

String String基础知识

1）字符串的值：在创建之后不能改变，但可以被共享，相当于字符数组char[]，底层原理是字节数组byte[]
2）构造方法

Sting s = new String();//无参构造

char[] ch = {'a', 'b', 'c'};
String s = new String(ch);

byte[] by = {97, 98, 99};
String s = new String(s);

String s = "abc";

3）字符串的比较
① “==”：基本类型：比较的是数据值是否相同；引用类型：比较的是地址值是否相同 //字符串不是基本类型，是一个类，比较的是地址。
字符串的字符序列相同（大小写和顺序），无论在代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护，本质上是同一个对象。
e.g. s1 = “ab” 与s2 = “ab” 是相同的（只针对直接赋值，相同的常量在常量池里面是同一个地址和数据，如果用char数组赋值，new了两个string，他们的地址是不同的）
② equals（）：字符串比较内容。

StringBuilder基础知识

1）概述：可变的字符串，可以看作是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的。

2）构造方法

StringBuilder sb = new StringBuilder();

StringBuilder sb = new StringBuilder("Hello");

3）添加和反转

StringBuilder sb = new StringBuilder();
sb.append("Hello");//添加数据，并且返回对象本身
sb.append("world").append("--").append("java");//链式编程
sb.reverse();//反转

String和StringBuilder的互相转换

1）StringBuilder转String：toString（）方法

StringBuilder sb = new StringBuilder();
sb.append("Hello");
String s = sb.toString();

2）String转StringBuilder：通过构造方法

String s = "Hello";
StringBuilder sb = new StringBuilder(s);

集合

概述：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变。

ArrayList

1）概述：由可调整大小的数组实现；是一种特殊的数据类型，泛型。
2）构造方法和添加方法

import java.util.ArrayList;
ArrayList array = new ArrayList<>();//或者ArrayList array = new ArrayList(); 都是可以的
array.add("hello");
array.add("java");//在集合末尾添加元素
array.add(1,"ok");//在指定位置（索引1）处添加ok元素

3）ArrayList集合常用方法

ArrayList array = new ArrayList<>();
array.add("hello");
array.add("world");
array.add("java");
array.remove("world");//删除指定元素，返回删除是否成功
array.remove(1);//删除指定位置的元素，返回被删除的元素
array.set(1,"javaaaaaaa");//修改指定位置的元素，返回被修改的元素
array.get(0);//返回指定索引处的元素
array.size();//获取集合的长度

继承

1）概述：面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法
2）继承的格式：

public class 子类名 extends 父类名{}

父类：又称为基类和超类
子类：又被称为派生类

3）继承中变量访问的顺序：先子类该函数内找，再子类成员范围内找，最后父类成员范围找

this和super

this：访问本类的成员变量、构造方法、成员方法
super：访问父类的成员变量、构造方法、成员方法

public class A extends B{
	public int age = 20;
	public void show(){
		int age = 30;
		System.out.println(age);//输出30
		System.out.println(this.age);//输出20
		System.out.println(super.age);//输出父类B的age
	}
}

public class A extends B{
	public void show(){
		super.show();//调用父类中的成员方法，如果有输出则输出
		System.out.println("子类中的成员方法被调用");//输出
	}//调用该方法会输出两条
}

继承访问特点 构造方法的访问特点

1）子类中所有的构造方法默认都会访问父类中无参的构造方法
原因：子类初始化之前，一定会先完成父类数据的初始化；所有每一个子类构造方法的第一条语句默认都是：super()
重点：如果父类中没有无参方法，只有带参构造方法，怎么办？

1. 通过super关键字去显示的调用父类的带参构造方法
2. 在父类中提供一个无参构造方法

成员方法的访问特点

先在子类成员范围找，再到父类成员范围找，如都没有，报错

方法重写

1）概述：子类中出现了和父类一模一样的方法声明。
2）@Override：注解，检查方法名是否与父类方法名一致，即检查重写方法的方法声明的正确性
3）注意事项：
私有方法不能被重写（父类私有成员子类是不能继承的）
子类方法访问权限不能低于父类（public > 默认：即不加public等关键字，直接void 方法名 > 私有）

JAVA中继承

注意事项：
Java中只支持单继承，不支持多继承：e.g. 不能 A extends B,C
Java中类支持多层继承：e.g. A extends B{}; B extends C{};

包

带包的java类编译和执行：windows下
手动建包：

1. javac Hello.java 编译java文件
2. 在该盘下建立包
3. 把class文件放进建立的包下面
4. java.com.Hello 带包执行

自动建包：javac -d . Hello.java ----> java com.Hello

修饰符 权限修饰符

修饰符	同一个类中	同一个包中的类	不同包的子类	不同包的无关类（即不继承该父类）
private	√
默认（即不加任何修饰符）	√	√
protected	√	√	√
public	√	√	√	√

状态修饰符

final：最终；可修饰成员方法、成员变量、类

1. 修饰方法：该方法为最终方法，不能被重写
2. 修饰变量：
   1）该变量基本类型变量：表明该变量为常量，不能再次被赋值
   2）该变量为引用类型变量：表明该变量地址不能变，里面的内容可以变

public static void main(String[] args){
	final int a = 1;
	//a = 2; 常量不能被修改
	final Student s = new Student();//Student类
	s.a = 2;//可以被改变，s代表成员变量的地址，不能 s = new Student(),地址不能重新赋值
}

4. 修饰类：表明该类为最终类，不能被继承

static：静态；

1. 被类的所有对象共享：判断是否使用静态关键字的条件
2. 可以通过类名调用

//类A
public class A{
	public static int number;
	public void show(){
		System.out.println(number);
	}
}
//测试调用类1
public class DemoOne{
	A a1 = new A();
	a1.number = 001;
	a1.show();
	A a2 = new A();
	a2.show();//输出的结果也是001，static共享
}
//测试调用类2
public class DemoTwo{
	A.number = 001;//A类的所有成员变量的number都是001，不需要再赋值（static的特点：通过类名访问）
	A a1 = new A();
	a1.show();
	A a2 = new A();
	a2.show();//输出的结果也是001，static共享
}

static访问特点
非静态的成员方法：访问静态和非静态都可
静态的成员方法：只能访问静态成员

多态

概述：同一个对象，在不同时刻表现出来的不同形态
前提和实现：

1. 有继承/实现关系
2. 有方法重写
3. 有父类引用指向子类对象

public class Animal{
	public void eat(){
		System.println("it is eating!");
	}
}
//继承Anima类
public class Cat extends Animal{//1.继承关系
	public void eat(){//2.方法重写
		System.println("CAT is eating!");
	}
}
//测试的类
public class EatDemo{
	public static void main(String[] args){
		Animal a = new Cat();//3.父类引用指向子类对象
	}
}