基本编程知识

1.数据类型

类型                      存储需求                 取值范围
int                       4 字节                 正好超过20亿
short                     2 字节                 -32768~32767
long                      8 字节                 -2的64~ 2的64-1
byte                      1 字节                 -128~ 127

1）长整型数值L后缀、十六进制ox前缀、八进制o前缀、二进制数值ob前缀，float后缀F。double 后缀D

2）Java 中没有无符号类型

3）可以用十六进制表示浮点数，十六进制中用p表示指数。注意:尾数采用十六进制，指数采用十进制，指数的基是2，而不是10

4）在Unicode 标准中代码点采用十六进制书写，并加上前缀U+

5）对于strictfp 标记的方法必须使用严格的浮点计算来产生理想的计算结果

6）Math.round(x) 方法的到x的精确的转换值

2.字符串变量

（1）用+可以连接两个字符串；

（2）非字符可以自动转换为字符格式；

import java.util.Scanner;
public class Nihao {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String s=new String("hello");
		System.out.println(s+21+23);//第一步将数字转换为字符格式
	}
}

1	结果： hello2123

（3）输入字符串

1
2
3

String s;
s=in.nextLine();//读入下面一行
s=in.next();//读入下一个单词

（4）比较两个String

if(input=="bye"){//比较是否是同一个东西
  ...
}
if(input.equals("bye")){//比较内容是否相同
    ...
}
//所以说比较String应该用.equals()来比较

3.字符串操作

(1) 字符串.操作表示对该字符串做”操作”，其中字符串可以是变量也可以是常量

//字符串比较大小的操作（比较UNICODE)编码大小
	    s1.compareTo(s2)//若s1小，则输出负值，s1大输出正值；
        s1.compareToIgnoreCase(s2)//不区分大小写进行比较
//获得Sting 的长度
        string.length();
//访问字符串里面的单个字符
        string.charAt(index);//返回在index上的单个字符，index的范围是0---length-1;
//得到子串
        string.substring(n);//得到从n号位置到末尾的全部字符
        string.substring(b,e);//得到从b号位置到e号位置之前！的内容
//寻找字符
        string.indexOf(c);//得到c字符（串）所在的位置，如果不存在则返回-1;
        string.indexOf(c,n);//从n号位置开始寻找c字符
        string.lastIndexOf(c);//从右边开始寻找字符（串）c，可以类别上述两个例子
//其他字符串操作
        s.startsWith(t);//判断字符串是否以t开始
        s.endsWith(t);//判断字符串是否以t结束
        s.trim();//删除字符串两端的空格
        s.replace(c1,c2);//把字符串中所有的c1换成c2;
        s.toLowCase();//转小写
        s.toUpperCase();//转大写

 /*注意，所有的对字符串的操作都是生成新的字符串，并不会改变原来的字符*/

4.Math类

//求绝对值
System.out.println(Math.abs(-12));//12
//四舍五入小数部分
System.out.println(Math.round(10.345));//10
//随机数
System.out.println(Math.random()*100);//0--100的随机数
//幂运算
System.out.println(Math.pow(m,n));//m的n次方（浮点数）

5.素数求和

public static boolean isPrime(int i)//定义一个返回值为布尔型的方法
{
		boolean isPrime=true;//先假设该数为素数
    	for(int k=0;k<i;k++){
            if(i%k==0){
                isPrime=false;//如果不满足条件则该数不是素数
                break;//终止循环
            }
        }
    return isPrime;//返回布尔型的值
}

6.求m到n的和

public static int figureOut(int i,int k)//定义一个返回int类型的方法
	{
		int sum=0;
		for(int a=i;a<=k;a++) {
			sum=sum+a;
		}
		return sum;//返回int类型的值
		
	}
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int m=in.nextInt();
		int n=in.nextInt();
		System.out.println(figureOut(m,n));//调用函数
	}

7.文件输入与输出

1）对文件的读取：

try {
		Scanner in = new Scanner(Paths.get("E:\\OneDrive\\桌面\\a.txt"));
		String a = in.nextLine();
		System.out.println(a);
		in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

2)对文件的写入

try {
		PrintWriter out = new PrintWriter("E:\\OneDrive\\桌面\\b.txt");
		out.print("你好我是文件b");
		out.close();
		
	} catch (IOException e) {
		e.getStackTrace();
	}

3）API

Scanner(File f) // 构造一个从指定文件读取的Scanner 对象
Scanner(String s) // 构造一个从给定字符串读取数据的Scanner

    PrintWriter(String fileName) // 构造一个写入指定文件的PrintWriter,文件名由参数指定
    
    static Path get(String pathname) // 根据给定的路径名构造一个path

8.块作用域

1）不能在嵌套的两个块中声明同名的变量

9.循环

1）如果希望程序至少执行一次，可以使用do-while语句

2）for语句的三个部分应该对同一个计数器变量进行初始化，检测和更新，否则程序的可读性较差

3）switch 语句时可加上@SuppressWarnings(“fallthrough”)消除对缺少break这种情况的警告

10.大数值

//java.math 中的两个大数值的类
BigInterger a = BigInterger.valueOf(100);
// 不能使用 + - 等运算符来处理大数值，而要使用add和multiply,如
BigInterger a = c.add(b);// a=c+b

BigDecimal a = BigDecimal.valueOf(100);//浮点数

11.数组

1)数组长度为0和null不一样

// 打印数组中的所有值
int [] a = new int[10];
for (int i = 0 ; i < a.length; i++) {
	a[i] = i + 1;
}
System.out.println(Arrys.toString(a));
// 数组拷贝
int [] prime = {1,2,3,4,5,6,7}
int [] lucky = prime;
lucky[5] = 12;// 此时prime[5]也是12
// 将一个数组中的数值全部拷贝到另一个数组
int [] first = arrays.copyOf(prime,2*prime.length); //这个方法通常用来增加数组的长度

// 数组排序
arrays.sort(first);
// 快速打印一个二维数组
System.out.println(Arrays.deepToString(a));

Java 与面向对象

一、对象与类（新）

1.1 面向对象程序设计概述

1）Java是完全面向对象的，面向对象的程序是由对象构成的

2）在OOP中不必关心对象的具体实现，只要满足用户的需求即可

3）OOP将数据放在第一位，然后再考虑操作数据的算法

4)java 中数据类型具有固定的长度

5）在网页中运行Java程序称为applet

1.1.1 类

1）由类构造对象的过程称为创建类的实例

2）封装（encapsulation) 是将数据和行为组合在一个包中

3）封装的关键在于隔离不同类之间的实例域，程序仅通过对象的方法对数据进行交互，封装给对象赋予了”黑盒“特征，提高了重用性和可靠性

4）继承子类拥有父类的全部属性和方法，在子类中只需提供适用于这些的新方法和数据域。

1.1.2 对象

1）对象的状态只能由调用对象的方法的形式改变，如果不需要调用对象的方法即可改变状态说明封装性遭到了破坏

2）每个对象的标识都是不同的

1.1.3 识别类

1）面向对象中不用从main函数开始编写程序，首先从设计类开始，然后在每个类中增加方法

2）识别类的简单规则是寻找名词，方法对应着动词

1.1.4 类之间的关系

1)依赖（use-a)如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类，要让类之间的耦合度最小

2)聚合(has-a)意味着一个类的对象包含另一个类的对象

3)继承（is-a)

1.2 使用预定义类

1）并不是所有类都具有面向对象特征,例如Math类，因为Math类只封装了功能

1.2.1 对象与对象变量

1）Java中使用构造器构造实例，构造器是一种特殊的方法，用来构造并初始化对象（构造方法）

2）对象与对象变量的区别（是否引用），多个对象变量可以引用一个对象

3）一个对象变量并没有实际包含一个对象，而仅仅引用了一个对象

4）例如 Date date = new Date(); 中，new Date() 构造了一个date类型的对象，并且它的值是对新创建对象的引用

5）可以显式地将对象变量设置为null，表明该变量没有引用任何

6）局部对象变量不会自动初始化，必须通过调用new 或将它们设置为null进行初始化

1.2.2 Java 类库中的GregorianCalendar 类

1）时间是距离一个固定时间点的毫秒数， UTC时间1970年一月一日 00:00:00

2）UTC（Coordinated Universal Time)，与格林威治时间一样，具有实践意义的科学标准时间

3）Java 设计将保存时间和给时间点命名分开，一个是Date类，另一个是GregorianCalendar类，GregorianCalendar有更通用的Calendar类

4）标准Java库包含泰国佛历和日本黄历

// 表示对象构造时的时间和日期
GregorianCalendar date = new GregorianCalendar();
// 构造一个自己设置时间和日期的对象
new GregorianCalendar(2001,Calendar.October,31,00,00,00);

1.2.3更改器方法和访问器方法

1）对实例域做出修改的方法称为更改器方法，仅仅访问实例域而不进行修改的方法称为访问器方法

2）Java中更改器方法和访问器方法在语法上没有明显的区别，通常用“set’和”get“字面区别

// 使用GregorianCalendar中的get方法获取信息
GregorianCalendar now = new GregorianCalendar();
int month = now.get(Calendar.MONTH);
int weekday = new.get(Calendar.DAY_OF_WEEK);
// 用set方法可以改变对象的状态
GregorianCalendar deadline = new GregorianCalendar();
deadline.set(2002,02,02);
// 为给定的日期增加数据
deadline.add(Calendar.MONTH,2);// 如果参数是负数，则时间倒退

定义类

1.类的最基本的要素是属性和方法

实现一个简单的自动售货机（vendingmachine)

方法调用（方法重载）

(1)this是成员函数的一个特殊的固有的本地变量，它表达了调用这个函数的那个对象

(2)定义在函数内部的变量是本地变量，外部的是成员变量

（3）构造方法：成员函数的名字和类的名字完全相同，则在创建这个类的每一个对象的时候会自动调用这个函数，没有返回类型；

（4）如果没有定义构造方法，JVM提供默认一个无参数的构造方法

（5）用override来标注方法的重写

对象和类

（1）成员变量不需要初始赋值

（2）private只能在成员变量或成员函数，表示这个东西只能在该类中访问

（3）初始化顺序：静态属性静态方法块普通属性普通方法块构造方法

（4）this关键字的三种用法：

指向当前对象

修饰属性

和构造方法一起使用充当全局关键字：this(参数)来调用其他构造方法，this（参数)语句必须放在构造方法的第一行

（5）super(参数)来调用父类中的构造方法

（6）封装原则

多态

多态的实现具有三种充要条件：继承重写父类方法父类引用指向子类对象

对象交互

组合

1.将对象引用置于新的类中，如果想让类具有更多的扩展功能，要多用组合少用继承

2.组合和继承的区别

代理

1.概念：A不直接调用B类的方法，A现在自己的类中创建一个B的对象的代理，再由代理去调B的方法

向上转型

STATIC

static除了修饰变量和方法外，还可以用于静态代码块功能，可用于类的初始化操作；

封闭的访问属性

对象=属性+服务；

把数据和对数据的操作放在一起——>封装

开放的访问属性

若不加public或private属性表示该成员friendly，可以在同一package下使用

包

import.包名.*；

一个点代表一个层次

类变量

static是类变量,带static 前缀的变量或函数只属于这个类，不属于对象

记事本

能存储记录

不限制记录数量

能知道已经存储的记录的数量

能查看存进去的每一条记录

能删除一条记录

能列出所有的笔记

接口设计

泛型容器类

ArrayList<String> notes = new ArrayList<String>;
//容器有两个类型：容器的类型和元素的类型
notes.get(index);//得到index的元素
notes.remove(index);//删除index的元素
notes.size();//得到长度
notes.toArray(a);//转移到数组a

对象数组

对象数组中的每个元素都是对象的管理者而非对象本身

FOR EACH

集合SET

集合里面没有重复的元素

HASH表


package coins;

import java.util.HashMap;
import java.util.Scanner;

public class Coin {
	private HashMap<Integer,String> coinnames= new HashMap<Integer,String>();
    //一个整数值和另外一个字符值相互对应。如果不存在返回null
	public Coin(){
	coinnames.put(1,"Zhang");
	coinnames.put(10,"You");
	coinnames.put(25,"Shuang");
	coinnames.put(50,"Sha");
	coinnames.put(100,"Bi");
    System.out.println(coinnames.keySet().size());//获得整数值的个数
    System.out.println(coinnames);//直接输出HASH表
       //获取字符值
        for(Integer k: coinnames.keySet()) {
     		String s=coinnames.get(k);
     		System.out.println(s);
     	}
	
}
public String getName(int amount) {
	return coinnames.get(amount);
   // if(coinnames.containsKey(amount))
		//return coinnames.get(amount);
	//优化，先判断是否存在，如果不存在返回特定字符串
//	else
	//	return "NOT FOUND";
}
public static void main(String[] args) {
	// TODO Auto-generated method stub
	Scanner in = new Scanner(System.in);
	int amount =in.nextInt();
	Coin coin=new Coin();
	String name=coin.getName(amount);
	System.out.println(name);

}

资料库

继承

子类父类关系

父类中的private东西子类不可见

解决方法：1.把父类中的private改为protected

2.在子类中加super();

异常处理

认识Exception

1.Exception 位于java.lang包下，它是一种顶级接口，继承于Throwable类。

2.Throwable

标准输入输出流定义

import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStreamReader;

public class Example {
    private static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
    private static PrintWriter stdOut = new PrintWriter(System.out,true)
}

final 关键字

final关键字可以修饰域，也可以修饰方法，还可以修饰类

// 修饰域：
[访问修饰符][static] final 数据类型名=值；
//修饰方法：final修饰的方法可以被子类继承，但不能被子类重写；
[访问修饰符][static] final 方法类型方法名([形参列表]){方法体}

注释里面的@see

see使用
语法格式： @see 全路径包名#方法名(参数类型列表)
@see 标签允许用户引用其他类的文档。具体使用方式如下：
@see classname
@see fully-qualified-classname
@see fully-qualified-classname#方法名称
@see fully-qualified-classname#属性名称