Table of Contents
- 1 第一个java程序，输出hello world
- 2 第二个java程序，输入a与b的值，然后输出 a+b
- 3 java当中的if语句
- 4 样例1
- 5 java同样支持三元运算符
- 6 switch条件语句
- 7 while循环语句
- 8 do – while 循环语句
- 9 java大数a+b
- 10 java数组冒泡排序
- 11jave如何调大字体（2019.9.17）
- 12多维数组的学习(2019.9.17)
- 13package是什么意思（20190924）
- 14super语句的用法（20190924）
- 15static在java当中（20190924）
- 16关于多态的学习（2019.9.29）
- 17 over在java中的作用（2019.9.29）
- 18 什么是内部类（2019.9.29）
- 19java中方法的重载和使用（20191008）
- 20java中函数的使用（20191008）
- 21java中的二分查找（递归）（20191008）
- 22.java中异常的学习
- 23.java中字符串类string的相关操作、
- （2019.11.19）24.如何在java中声明一个类，并対类变量进行排序
- 25有关容器接口的相关学习资料
1 第一个java程序，输出hello world
package com.itheima.first;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
2 第二个java程序，输入a与b的值，然后输出 a+b
import java.util.Scanner;
//上面这句话在提交代码的时候不能省略
public class Main {
public static void main(String args[])throws Exception{
Scanner cin = new Scanner(System.in);
int a = cin.nextInt(), b= cin.nextInt();
System.out.println(a+b);
}
}3 java当中的if语句
如果满足某种条件就进行某种处理
if(语句块){
执行语句1;
}
//------------
if(判断条件） {
执行语句1;
...
}
else {
执行语句2;
...
}4 样例1
输入学生成绩，通过if语句判断学生等级
package demoif;
import java.util.*;
public class Exampleif {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int score;
Scanner input = new Scanner(System.in);
score = input.nextInt();
if(score >= 90){
System.out.println("A");
}
else{
if(score >= 80)
System.out.println("B");
else
System.out.println("c");
}
}
}
5 java同样支持三元运算符
（无具体内容）
6 switch条件语句
switch（只能是int或者是char或者是符合条件的值）
{
case 1:
执行语句1;
break;
...
}
//要记得break否则所有内容都执行注意case存在穿透现象
7 while循环语句
8 do – while 循环语句
9 java大数a+b
package demoif;
import java.math.BigInteger;
import java.util.*;
import java.math.BigDecimal;
import java.util.Scanner;
public class Exampleif {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger a, b;
Scanner input1 = new Scanner(System.in);
a = input1.nextBigInteger();
b = input1.nextBigInteger();
BigInteger c = a.add(b);
System.out.println(c);
}
}
10 java数组冒泡排序
与C、C++不同，Java在定义数组时并不为数组元素分配内存，因此[ ]中无需指定数组元素的个数，即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的，我们必须要为它分配内存空间，这时要用到运算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize 为数组的长度，type 为数组的类型。如：
- demoArray=new int[3];
为一个整型数组分配3个int 型整数所占据的内存空间。
通常，你可以在定义的同时分配空间，语法为：
type arrayName[] = new type[arraySize];
例如：
int demoArray[] = new int[3];
package demoif;
import java.math.BigInteger;
import java.util.*;
import java.math.BigDecimal;
import java.util.Scanner;
public class Exampleif {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int [] a = new int [10];
Scanner input = new Scanner(System.in);
for(int i = 0; i < a.length; i++){
//Scanner input1 = new Scanner(System.in);
a[i] = input.nextInt();
}
//System.out.println(c);
bsort(a);
ansprint(a);
}
public static void bsort(int [] a) {
for(int i = 0; i < a.length - 1; i++){
for(int j = 0; j < a.length - 1 - i; j++){
if(a[j] > a[j+1]){
int t;
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
public static void ansprint(int [] a) {
for(int i = 0; i < a.length; i++){
System.out.println(a[i]);
}
}
}
11jave如何调大字体（2019.9.17）
https://blog.csdn.net/qq_41694906/article/details/81182700
12多维数组的学习(2019.9.17)
package cheapet01;
import java.util.Scanner;
public class array {
/**
* @param args
*/
/*
* 有一个n*n的棋盘，每个棋位上都输入一个数字，求解，棋盘上所有数字的和是多少
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//多维数组的申请和使用
int n;
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
int [][] arr = new int [n][n];
for(int i = 0; i < n; i++){
for(int j = 0; j <n; j++){
arr[i][j] = cin.nextInt();
}
}
//这是一个n*n大小的棋盘
int sum = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j <n; j++){
sum += arr[i][j];
}
}
cin.close();
System.out.println(sum);
}
}
13package是什么意思（20190924）
在java项目中package相当于是一个文件夹用于对class类文件（即.java文件进行分类和保存的上级目录），因此每次在创建java project的时候都要记得下一步创建的package然后在相应的package下创建class文件
14super语句的用法（20190924）
内容学习参考于传送门
super( )其实就相当于一个指向基类的指针，（要记住Java中没有指针，但是可以这样理解）。
- super.XXX( 这里的XXX指的是父类的成员变量名即父类的属性，或者对象名）
- super.XXX( ) ( 这里的XXX是父类中的其中一个方法名)
- super( ) ( 这种形式指的是：调用父类没有参数的构造方法（也叫构造函数）注意： 这里super( ) 只能放在子类的构造方法里面，并且只能放在构造方法的首句)
super( x,y,z…) （此形式指：调用父类有参数的构造方法，也必须放在子类的构造方法（成员方法不可以）里面，并且只能放在构造方法的首句。其中x,y,z是指的与父类此有参构造方法中参数数据类型相对应的子类中的参数）
——————————-java文件创建情况————————————
父类代码
package cheapt01;
public class Father {
protected String head = "父类进行输出了";
Father(){
System.out.println(head);
}
Father(int a){
System.out.println(a);
}
}
子类代码
package cheapt01;
public class Son extends Father{
private static int a = 1;
public Son(){
System.out.println(super.head);
//由于继承了父类，因此可以直接调用父类中的字符串
}
public void test(){
//测试函数
}
public static void main(String[] args){
Son s = new Son();
}
}
extends在java中的含义就意味着继承
可以很清楚的看到main函数中申请了一个名字为s的Son变量，那么就会调用父类中的String
15static在java当中（20190924）
static:静态的，用于修饰成员(成员变量，成员方法);
1.被static所修饰的变量或者方法会储存在数据共享区;
2.被static修饰后的成员变量只有一份！
3.当成员被static修饰之后，就多了一种访问方式，除了可以被对象调用之外，还可以直接
被类名调用，(类名.静态成员);
4.static的特点：
1）随着类的加载而被加载;
2）优先于对象存在;
3）被所有对象共享;
5.被static修饰的变量成为静态变量(类变量)或者实例变量;
6.存放位置
1）类变量随着类的加载而存在于date内存区;
2）实例变量随着对象的建立而存在于堆内存;
7.生命周期：
1)类变量周期生命最长，随着类的消失而消失;
2)实例变量生命周期比类变量短，它是随着对象的消失而消失;
8.方法注意事项：
1)静态的方法只能访问静态的成员;
2)非静态得方法即能访问静态得成员(成员变量，成员方法)又能访问非静态得成员;
3)局部变量不能被static修饰;
4)静态得方法中是不可以定义this、super关键字的，因为静态优先于对象存在，所以静态方法不可以出this;
9.什么时候使用static修成员：
当属于同一个类的所有对象出现共享数据时,就需要将存储这个共享数据的成员用static修饰;
10.什么时候使用static修饰方法：
当功能内部没有访问到非静态的成员时（对象特有的数据）那么该功能可以定义成静态的;
16关于多态的学习（2019.9.29）
什么是多态？
多态是指不同类对象在调用同一个方法时所呈现出的多种不同行为。
多态的作用：通过多态消除了类之间的耦合关系，大大提高了程序的可扩展性和可维护性
注意：一个父类可以有多个子类，但是一个子类只能有一个父类。（区别于接口）
如下典型的向上转型
Animal a = new Dog();向下转型：
Animal a =new Dog();
Dog b = (Dog) a;(向下转型是不安全的，所以有这么一个判断关键词）
if(an1 instanceof Cat){
}
else{
}通过instanceof 进行判断，在向下转型的过程中判断与哪一个子类对象是对应的，然后在进行转型，避免了向下转型的错误，并且提高了程序的可读性和安全性。
17 over在java中的作用（2019.9.29）
@Override是伪代码,表示重写(当然不写也可以)，不过写上有如下好处: 1、可以当注释用,方便阅读； 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。例如，你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通过的，因为编译器以为这个方法是你的子类中自己增加的方法。 举例：在重写父类的onCreate时，在方法前面加上@Override 系统可以帮你检查方法的正确性。 @Override public void onCreate(Bundle savedInstanceState)
18 什么是内部类（2019.9.29）
在java当中，允许在一个类内部再定义一个类。
成员内部类，定义：在一个类中除了可以定义成员变量、成员方法，还可以再定义一个成员类
内部类可以调用外部类的变量和方法
注意外部类变量在使用的时候无法想直接使用内部类的函数
（在编译器中直接报错无法运行）
package day9282;
public class Outer{
int o = 10;
public void oMethod(){
System.out.println("外部类输出函数");
}
class Innner{
int i = 20;
public void iMethod(){
System.out.println("内部类输出函数");
}
}
}package day9282;
public class Demon01{
public static void main()(String []args){
//主程序口
}
}19java中方法的重载和使用（20191008）
在c++当中，存在着这么一种方法，就是对函数的重载，使得程序变得更加的高效。
简单介绍：它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，编译器就会根据不同的参数样式，来选择合适的方法执行。
注意，是定义不同的输入参数来区分方法（因为重载的函数，函数名字是相同的）
20java中函数的使用（20191008）
通常我们定义函数会定义在一个公共类当中，而不是直接写在主类的下方，那么我们在调用类外函数的时候应该怎么样去书写它呢？
那么就是先写类的名字然后加上.（这个点在这里是引用的意思，相信写过c++或者是c的朋友不会陌生）然后在加上方法名（通常引用点一写就会跳出来供你选择）
具体样例
package cheapt01;
public class Example05 {
//java当中方法的重载
public static int add(int x, int y){
return x+y;
}
public static int add(int x,int y,int z){
return x+y+z;
}
public static double add(double x,double y){
return x+y;
}
}
package cheapt01;
import java.util.Scanner;
public class demo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int x, y, z;
Scanner cin = new Scanner(System.in);
x = cin.nextInt();
y = cin.nextInt();
z = cin.nextInt();
int tmp1 = Example05.add(x,y,z);
int tmp2 = Example05.add(x,y);
System.out.println(tmp1);
System.out.println(tmp2);
}
}21java中的二分查找（递归）（20191008）
package cheapt01;
public class Example07 {
//二分查找递归方法
public static int HalfSearch(int a[],int key, int start,int end){
int mid = (start + end) >> 1;
if(key == a[mid]){
System.out.println(mid);
return 0;
}
else if (key < a[mid]){
HalfSearch(a, key, start, mid);
}
else if(key > a[mid]){
HalfSearch(a, key, mid, end);
}
else{
System.out.println("error");
return -1;
}
return -1;
}
}package cheapt01;
import java.util.Scanner;
public class demo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n;
System.out.println("请输入n值");
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
int [] a = new int [n];
System.out.println("请输入n个数字");
for(int i = 0; i < n; i++){
a[i] = cin.nextInt();
}
for(int i = 0; i < n - 1; i++){
for(int j = 0; j < n - i - 1; j++){
if(a[j] > a[j+1]){
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
int key;
System.out.println("请输入key值");
key = cin.nextInt();
Example07.HalfSearch(a, key, 0, n-1);
}
}22.java中异常的学习
参考于：https://www.cnblogs.com/taiwan/p/7073743.html
一, 什么是java里的异常
1.1 c语言里的错误
我们实现1个程序的过程包括, 代码编写, 编译代码成为程序, 执行程序
其中大部分常见的语法错误都会被编译代码这样部过滤掉. 但是即使通过了编译. 执行程序这一步可能还是会有错误.
1.2关于java
java是有cc++发展而来的，java当中依然存在于类似于cc++中的异常情况，c++和c中的解决办法一般是提前进行判断，或者是异常抛出判断
例如如下程序（除程序，当分母为0时会出现异常）
package test01;
import java.util.Scanner;
public class Demo01 {
public static int div(int a, int b){
return a/b;
}
//除函数，当b == 0 的时候会出现异常
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a, b;
Scanner cin = new Scanner(System.in);
a = cin.nextInt();
b = cin.nextInt();
int ans = div(a, b);
System.out.println(ans);
}
}
出现异常
但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与文件行数输出, 方便你调试. jvm虚拟机是会对错误作出一定的处理的.
所以可以简单地将java里的异常理解成java运行时出现的错误, 异常机制就是对这种错误进行处理的机制.
二, java里的异常的分类.
xxxxxx ArithmeticException
package test01;
import java.util.Scanner;
public class Demo01 {
public static int div(int a, int b){
int i = 0;
try{
i = a/b;
}
catch (Exception e){
System.out.println("Exception occur!");
System.out.println(e.getMessage());//输出原因
}
}
//除函数，当b == 0 的时候会出现异常
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a, b;
Scanner cin = new Scanner(System.in);
a = cin.nextInt();
b = cin.nextInt();
int ans = div(a, b);
System.out.println(ans);
}
}
23.java中字符串类string的相关操作、
package Day1022;
import java.util.Random;
public class Demo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// string 类的常见操作
String Str1 = ""; //string的第一种声明方式 无参数
String Str2 = null; //string的第二种声明方式 无参数，指向空指针
String Str3 = "abs";//string的第三种声明方式
char []charArry = new char []{ 'A', 'B', 'C'};
String Str4 = new String(charArry); //通过已知数组对string进行初始化
String Str5 = new String(Str3); //使用已知的string类对新string进行初始化
/*
下面进行string类常用操作的测试
*/
String StrTest = "abuciketdncbcgdketduq";
/*
* 返回指定字符在此字符串中第一次出现的索引
*/
Demo01.Pri(StrTest);
int Test1 = StrTest.indexOf('d');
System.out.println("(1)String.indexOf find the char d first take place in " + Test1);
/*
* 返回指定字符在字符串中最后一次出现的索引
*/
int Test2 = StrTest.lastIndexOf('b');
System.out.println("(2)String.lastIndexOf: find the char b last take place in " + Test2);
/*
* 返回指定字符在此字符串中第一次出现的索引
*/
int Test3 = StrTest.indexOf("ket");
System.out.println("(3)String.indexOf: find the string {ket} first take place in " + Test3);
/*
* 返回指定字符串在此字符串中最后一次出现的索引
*/
int Test4 = StrTest.lastIndexOf("ket");
System.out.println("(4)String.lastIndexOf: find the string {ket} last take place in " + Test4);
/*
* 返回字符串中指定位置index上的字符
*/
System.out.println("返回字符串中指定位置index上的字符");
System.out.print("(5)");
for (int i = 0; i < StrTest.length(); i++) {
if(i == 0) System.out.print(i); else System.out.print(" " + i);
}
System.out.println();//换行
System.out.print("(6)");
for(int i = 0; i < StrTest.length(); i++){
if(i == 0) System.out.print(StrTest.charAt(i)); else System.out.print(" " + StrTest.charAt(i));
}
/*
* 判断字符串是否以指定字符结尾
*/
//System.out.println(StrTest.endsWith('q'));
System.out.println();
System.out.print("(7)StrTest.endsWith: judge whether string {q} is the end character of a string , the answer is " + (Boolean)StrTest.endsWith("q"));
}
public static void Pri(String s){
System.out.println("test answer : " + s);
}
}
test answer : abuciketdncbcgdketduq
(1)String.indexOf find the char d first take place in 8
(2)String.lastIndexOf: find the char b last take place in 11
(3)String.indexOf: find the string {ket} first take place in 5
(4)String.lastIndexOf: find the string {ket} last take place in 15
返回字符串中指定位置index上的字符
(5)0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
(6)a b u c i k e t d n c b c g d k e t d u q
(7)StrTest.endsWith: judge whether string {q} is the end character of a string , the answer is truepackage Day1022; public class Eample03 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub String str = "java"; char [] charArry = str.toCharArray(); System.out.println("make the string to be char[] : "); for (int i = 0; i < charArry.length; i++) { if(i == 0) {System.out.print(charArry[i]);} else{System.out.print(" " + charArry[i]);} } } }
（2019.11.19）24.如何在java中声明一个类，并対类变量进行排序
extends与implements的不同
1、在类的声明中，通过关键字extends来创建一个类的子类。
一个类通过关键字implements声明自己使用一个或者多个接口。
extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法;
implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
2、extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承
Java中不支持多重继承，但是可以用接口 来实现，这样就要用到implements，继承只能继承一个类，
但implements可以实现多个接口，用逗号分开就行了 比如 ：
class A extends B implements C,D,E
接口实现的注意点：
a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。
b.接口中的方法都是抽象的。
c.多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口
这里我解答的是 PAT (Basic Level) 1004
【题目】输入n个学生的姓名、学号、成绩，找出成绩最好的和成绩最差的，进行输出
【解题思路】声明一个学生类，対学生类进行一下排序
【知识点】
- 対类进行排序，需要重写compare
- 如何声明一个类数组 student [] arr = new student [n];
- java中的容器排序算法 Arrays.sort( 容器名字, 容器起始位置，容器结束位置)：
- 接口的使用
- split的使用，按照特殊的符号対字符串进行分割，可以再输入的时候直接使用，十分的方便
（1）split表达式，其实就是一个正则表达式。* ^ | 等符号在正则表达式中属于一种有特殊含义的字符，如果使用此种字符作为分隔符，必须使用转义符即\加以转义。（2）如果使用多个分隔符则需要借助 | 符号，如二所示，但需要转义符的仍然要加上分隔符进行处理（3）字符串.split(分隔符号);
- 使用Arrays.sort一定需要加上接口Comparable ，并且程序内重写的是compareTo而不是compare
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
class student implements Comparable <student>{
String name = null;
String num = null;
int score = 0;
public student(String rname, String rnum,int rscore ){
name = rname;
num = rnum;
score= rscore;
}
@Override
public int compareTo(student a) {
// TODO Auto-generated method stub
return a.score - this.score;
}
}
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n; Scanner cin = new Scanner(System.in);
n = cin.nextInt();
student [] arr = new student [n+1];
cin.nextLine();
for(int i = 0; i < n; i++){
String tmp = cin.nextLine();
String []stu = tmp.split(" ");
int t = Integer.valueOf(stu[2]).intValue();
arr[i] = new student(stu[0], stu[1], t);
}
Arrays.sort(arr, 0, n);
System.out.println(arr[0].name + " " + arr[0].num);
System.out.print(arr[n-1].name + " " + arr[n-1].num);
}
}
25有关容器接口的相关学习资料
https://blog.csdn.net/qq_30447263/article/details/83034711
26容器的学习
package Day03;
import java.awt.List;
import java.util.ArrayList;
public class Demo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* @author ： scbtxdy
* ArrayList 是 List接口的一个实现类， A仍然有List内部封装了一个长度可变的数组对象
* ArrayList add 增加一个元素 get读取该位置上的元素 size()返回该集合的大小
*
*/
ArrayList list = new ArrayList();
list.add("first");
list.add("second");
list.add("third");
System.out.println(list);
System.out.println("集合大小 = "+list.size());
System.out.println("集合当中第二个元素 = "+ list.get(1));
list.set(0, "first had be replace");
System.out.println("对集合第一个位置进行了操作 ： "+list.get(1));
System.out.println("返回对象o在集合内第一次出现的索引" + list.indexOf("second"));
list.add("four"); list.add("five"); list.add("six"); list.add("seven");
/*
* 20191203
* subList 的坑 https://www.cnblogs.com/latteyan/p/7644527.html
* 子序列指向的地方还是原序列的地方
* 修改子序列原序列也会受到修改，因为函数的内部是引用
*/
System.out.println("子序列"+list.subList(3, 5));
/*
* ArrayLsit 集合查询元素的速度极快，但在增删元素时候的效率极低，为了克服这种局限，可以使用List接口的另一个实现类LinkedList
* 该集合内部饱和两个Node类型的first和last属性维护一个双向循环链表，链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，
* 从而可以将所有元素彼此链接起来。
*/
}
}