Java基础

Java

Java是一个纯面向对象的语言。（把实体、概念等抽象成对象，给对现象赋属性、行为。）
Java语法基础

关键字、保留字
关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）；关键字中所有字母都为小写。this、super、package、super
this：如果形参与成员变量同名时，在 方法 内或 构造器* 内需要使用成员变量， this.属性 表示成员变量。使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。
super：super可用于访问父类中定义的属性;super可用于调用父类中定义的成员方法;super可用于在子类构造器中调用父类的构造器。
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识。
final：final标记的类不能被继承；final标记的方法不能被子类重写；final标记的变量(成员变量或局部变量)即称为常量。

保留字：尚未使用，但以后可能被作为和关键字使用。

标识符(Identifier)
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。（凡是自己可以起名字的地方都叫标识符。）
定义合法标识符规则：
由26个英文字母大小写，0-9 ，_或 $ 组成；不可以使用但能包含关键字和保留字，不可以数字开头，不能包含空格；区分大小写，长度无限制。

变量
先声明、后使用。
1）数据类型 变量名称；
变量名称 = 值；
2）数据类型 变量名称 = 初始值；
分类：基本数据类型、引用数据类型。

基本数据类型转换：基本数据类型进行转换时按容量小转到大，byte、short、char之间不能相互转换，他们在计算时首先转为int。
强制数据类型转换：容量大像容量小的转换，可能会造成精度损失。字符串不能直接转换为基本数据类型，可以通过包装类实现。
String a = ‘123’;
int i = Integer.parselen(a);

运算符
算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三元运算符。

程序流程控制
顺序结构、分支结构(if…else、switch-case)、循环结构(while、do…while、for)。
1)

if(条件表达式){
				
				}else if(条件表达式){
				
				}......
				else{
				
				}

2）

switch(表达式){
case 常量1：
		语句1；
		//break;
case 常量2：
		语句2；
		//break;
		......
case 常量N：
		语句N；
		//break;	
default:
语句；
//break;
}

for(初始化;条件;迭代){
		循环体；
}

初始化部分；
while(循环条件){
		循环体；
		迭代；
}

初始化部分；
do{
		循环体；
		迭代；
}while(循环条件)

2 数组
一维数组初始化：

int[] arr = new int[2];
arr[0] = 3;
arr[1] = 2;

String names[];
names = new String[2];
names[0] = "一一"；
names[0] = "二二"；

int arr[] = new int[]{1,2,3};
或
int[] arr = {1,2,3};
或
String names[] = {"一一","二二"}；

多维数组：

int[][] arr = new int[2][3];
int[][] arr = new int[2][];
int[][] arr =  new inr [][]{(1,2,3),(4,5,6),(7,8)};

import java.util.Arrays;
public class SortTest{
	public static void main(String[] args){
		int [] numbers = {5, 900,1,5,77,30,64,700};
		Arrays.sort(numbers);
		for(int i = 0;i <numbers.length;i++){
			System.out.println(numbers[i]);
		}
	}
}

** 面向对象**
将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
类和对象是面向对象的核心概念。
创建对象的语法：
类名 对象名 = new 类名();
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

public class Person{
	public static void main(String args[]){
	Student s1 = new Student();
	Student s2 = new student();
	s1.study();//访问方法
	s2.id = 1;//访问属性
	System.out.println(s2.id);
	}
}
class Student(){
	int id;
	public void study(){
		System.out.println("活到老，学到老")；
	}
}

在一个类中,类中的方法可以直接访问类中的成员变量。
在不同类中：先创建要访问类的对象，再用对象访问类中定义的成员。
也可以不实例化，而直接调用这个对象的方法，这样的对象叫做匿名对象。当对方法只进行一次调用的时候，可以使用匿名对象。
如：new Person().shout();

class Person{
	//属性
	String name;
	boolean isMarried;
	//构造器
	public Person(){};
	public Person(String n,boolean im){
		name = n;
		isMarried = im;
	}
	//方法
	public void walk(){
		System.out.println("走路");
	}
	public String dsiplay(){
		return "名字："+name",Married:"+isMarried;
	}
	//代码块
	{
		name = "一一";
		age = "18";
		isMarried = false;
	}
	//内部类
	class pet{
		String name;
		float weight;
	}
}

类的成员：属性、方法。
属性：在方法体外，类体内声明的变量称为成员变量；在方法体内部声明的变量称为局部变量。

	成员变量	局部变量
声明的位置	直接生命在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	不能用劝你西安修饰符修饰、可以用final修饰
初始化值	有默认的初始化值	没有默认的初始化值、必须显示赋值，方可使用
内存加载位置	对空间或静态域内	栈空间

方法：将功能封装为方法的目的是，可以实现代码重用，简化代码。 Java里的方法不能独立存在，所有的方法必须定义在类里。
方法的声明格式：
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝
修饰符：public、缺省、private、final
void没有返回值。
方法的重载
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数
类型不同即可。
重载与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
型)。调用时，根据方法参数列表的不同来区别。
面向对象的特征

1. 封装性 ：为私有的(private)，再提供公共的(public)方法:getXxx()和setXxx()实现对该属性的操作，以实现隐藏一个类中不需要对外提供的实现细节；使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；便于修改，增强代码的可维护性。

2. 继承性 ：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。A extends B。
   子类继承了父类，就继承了父类的方法和属性。
   在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。 子类不能直接访问父类中私有的(private)的成员变量和方法。

3. 多态性：父类的引用指向子类的对象。（就是如果声明的对象是父类的，但却用它调用了子类的方法或者属性，这使得非法的，因为父类中根本没有定义这个属性或者方法）

构造器的特征:
它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
构造器的作用：创建对象；给对象进行初始化。每个类都至少有一个构造器；默认构造器的修饰符与所属类的修饰符一致；一旦显式定义了构造器，则系统不再提供默认构造器；一个类可以创建多个重载的构造器，父类的构造器不可被子类继承。
如：Order o = new Order(); Person p = new Person(“Peter”,15);
一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。

方法重写：：在子类中可以根据需要对从父类中继承来的方法进行改造，也称
为方法的重置、覆盖。运行时，子类的方法会覆盖父类的方法。

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限 子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常

包装类：

int i = 500; Integer t = new Integer(i);
Float f = new Float(“4.56”);
Float f = Float.parseFloat(“12.1”);//String类转化为基本数据类型
String fstr = String.valueOf(2.34f);//基本数据类型转化为String类

int i = 500;
Integer t = new Integer(i);
String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字
int j = t.intValue(); // j = 500，intValue取出包装类中的数据
String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型

抽象类、抽象方法（用abstract修饰）
abstract修饰私有方法、静态方法、final的方法、final的类

abstract class A {
	abstract void m1();
	public void m2() {
		System.out.println("A类中定义的m2方法");
	} 
}
class B extends A {
	void m1() {
	System.out.println("B类中定义的m1方法");
	}
 }
public class Test {
	public static void main(String args[]) {
		A a = new B();
		a.m1();//B中重写的子类方法
		a.m2();//A中的方法
	} 
}

代码块
代码块的作用： 对Java类或对象进行初始化
代码块(或初始化块)的分类：
一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块
(static block)，没有使用static修饰的，为非静态代码块。

接口（interface）
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有抽象方法都默认是由public abstract修饰的。
接口中没有构造器。
接口采用多继承机制。

interface Runner {
 	public void run();
 }
interface Swimmer {
	public double swim();
}
class Creator{
	public int eat(){
		…
	}
} 
class Man extends Creator implements Runner ,Swimmer{
	public void run() {
	……
	}
	public double swim() {
	……
	}
	public int eat() {
	……
	}
}

异常处理
java.lang.RuntimeException

1. ClassCastException
2. ArrayIndexOutOfBoundsException
3. NullPointerException
4. ArithmeticException
5. NumberFormatException
6. InputMismatchException

java.io.IOExeption
java.lang.ClassNotFoundException
java.lang.InterruptedException
java.io.FileNotFoundException
java.sql.SQLException
处理机制

try{
...... //可能产生异常的代码
}
catch( ExceptionName1 e ){
...... //当产生ExceptionName1型异常时的处置措施
}
catch( ExceptionName2 e ){
...... //当产生ExceptionName2型异常时的处置措施
}[ finally{
...... //无论是否发生异常，都无条件执行的语句
} ]

public void readFile(String file) throws FileNotFoundException {
……
// 读文件的操作可能产生FileNotFoundException类型的异常
FileInputStream fis = new FileInputStream(file);
..……
}

多线程
void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
方式一：

class Window extends Thread{
    private static int ticket = 100;
    @Override
    public void run() { //重写run()方法
        while(true){
           if(ticket > 0){
                System.out.println(getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
 }
public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();


        t1.setName("窗口1");//设置线程名称
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();//启动线程
        t2.start();
        t3.start();

    }
}

方式二：

class Ticket implements Runnable {
	private int ticket = 100;
	public void run() {
		while (true) {
			if (tick > 0) {
				System.out.println(Thread.currentThread().getName()+"售出车						票，ticket号为：" + ticket--);//放回当前线程获取线程名
            } else
		   	   break; 
		}
	} 
}
class TicketDemo {
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		t1.start();
		t2.start();
		t3.start();
	}
 }

集合

• Collection接口：单列数据，定义了存取一组对象的方法的集合，

  1. List：元素有序、可重复的集合
  2. Set：元素无序、不可重复的集合

  Map接口：双列数据，保存具有映射关系“key-value对”的集合，一个键只能对应一个值，键不能重复，值可以重复。常见集合HashMap、LinkedHashMap。

	HashMap<K,V>	LinkedHashMap<K,V>
存储数据	哈希表结构	哈希表结构+链表结构+红黑树
存取顺序	不能保证一致	链表结构可以保证元素的存取顺序一致
泛型变量(使用时赋类型)	数据类型可以相同，也可以不同	数据类型可以相同，也可以不同

一个key-value构成一个entry，所有的entry构成的集合时Set

Iterator iter = coll.iterator();
while(iter.hasNext()){//判断是否还有下一个元素
Object obj = iter.next();
if(obj.equals("Tom")){
iter.remove();
} }

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        coll.add(123);//
        coll.add(456);
        coll.add(343);
        coll.add(343);

        coll.forEach(System.out::println);//遍历
    }

public void testListRemove() {
	List list = new ArrayList();
	list.add(1);
	list.add(2);
	list.add(3);
	updateList(list);
	System.out.println(list);//
}
private static void updateList(List list) {
	list.remove(2);
}

 Map<String, String> map = new HashMap<String,String>();  //数据采用的哈希表结构
        //给map中添加元素，若key在集合中存在，则返回值为集合中替换前的键值，并把指定键所对应的值，替换成指定的新值
        map.put("奶茶", "开心");
        map.put("炸鸡", "快乐");
        System.out.println(map); // {奶茶=开心, 炸鸡=快乐}

        System.out.println(map.put("奶茶", "脂肪")); // 快乐
        System.out.println(map); // {{奶茶=开心, 炸鸡=快乐}
 
        //根据指定的key获取对应的value
        String en = map.get("炸鸡");
        System.out.println(en); // 开心
/根据key删除元素,会返回key对应的value值
        String value = map.remove("奶茶");
        System.out.println(value); // 脂肪
        System.out.println(map); // {炸鸡=快乐}


//for each

for（元素类型 元素变量：遍历对象）{
	循环体
}

TreeMap 存储key-value对是有序的。
Key 的排序：

• 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有 的 Key 应该是同一个类的对象，否则将会抛出
  ClasssCastException
• 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key进行排序。此时不需要 Map 的 Key 实现 Comparable 接口

Comparable接口中只有compareTo一个方法，实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）https://www.cnblogs.com/lin-jing/p/8278271.html

• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或 者compare()方法返回0