Java程序设计实践课程（主编：潘浩）重点整理

NEMO不爱敲代码

于 2021-12-26 16:41:56 发布

阅读量477

点赞数 5

分类专栏： Java 期末速成文章标签： java

本文链接：https://blog.csdn.net/NEMO_051129/article/details/121985337

版权

Java 同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

期末

1 篇文章 0 订阅

订阅专栏

速成

1 篇文章 0 订阅

订阅专栏

期末复习总结自用，大家也可以看看，欢迎讨论！（小白一个，有错勿怪）

所用Java编译器Eclipse

基础知识：

1.Java程序语句执行的顺序结构涵盖4种基本控制顺序：顺序结构，选择结构，循环结构，异常处理逻辑结构（若只有三个空，就写前三个）

2.权限修饰符：public，protected，default（默认），private

3.关键字：

private	私有的
protected	受保护的
public	公共的
类，方法和变量修饰符
abstract	声明抽象
class	类
extends	继承、扩展
final	最终、不可改变
implements	实现
interface	接口
native	本地
new	新，创建
static	静态
strictfp	严格，精准
synchronized	线程、同步
transient	短暂
volatile	易失
程序控制语句
break	跳出、中断
continue	继续
return	返回
do	运行
while	循环
if	如果
else	否则
for	循环
instanceof	实例
switch	观察
case	返回观察里的结果
default	默认
错误处理
try	捕获异常
catch	处理异常
throw	抛出一个异常对象
throws	声明一个异常可能被抛出
包相关
import	引入
package	包
基本类型
boolean	布尔型
byte	字节型
char	字符型
double	双精度
float	浮点
int	整型
long	长整型
short	短整型
null	空
TRUE	真
FALSE	假
变量引用
super	父类，超类
this	本类
void	无返回值
保留字
goto	跳转
const	静态
native	本地

4.注释：// 单行注释 /* 多行注释*/ /** 文档注释 **/

5.标识符：由字母、数字、下划线 [ _ )和$组成；不能以数字开头；不能是Java中的关键字。

6.boolean-->true/false。

7.类型转换

（1）自动类型转换：容量小转换成容量大的数据类型小-->大

double > float > long > byte , short , int （byte,short,int计算时转int)

（2）强制类型转换：容量大转换成容量小的数据类型大-->小

要加强制转换符！

例：

int c=3;
float b;
c=(int)b;

8.定义类

class C{
    ...
}//定义类C

9.对象实例化

C c = new C();//对象实例化

10.变量的定义

【按数据类型分】：基本数据类型变量；引用数据类型变量。

【按声明的位置】：局部变量；成员变量。

11.变量赋值

float a = 51.1f 
//float a = (float)133.3 的简写形式
long b = 1129l
//long b = (long)51129 的简写形式
char c = '周'
//char c = (char)周

12.运算符

算数
+ - * / % ++ --

赋值
=

关系运算符
> < >= <= == !=

逻辑运算符
! & \| && \|\|

条件运算符
XX?X:X

条件运算符实例：

int b=a>3?0:1;
//若a>3返回0，若a<3返回1

选择语句：

int a = 511;
if(a>=100){
    System.out.println("正确");
}
/*
if（）{
    ...
}*/
char b = '周子舒';
if (b=='周子舒'){
    System.out.println("周子舒");
}else{
    System.out.println("温客行");
}
/*
if (){
    ...
}else{
    ...
}*/
char c = '周子舒';
if (c=='周子舒'){
    System.out.println("周子舒");
}else if (c=='温客行'){
    System.out.println("温客行");
}else if (c=='周絮'){
    System.out.println("周絮");
}
/*
if (){
    ...
}else if(){
    ...
}*/
switch (str){
    case 1:
        System.out.println("周子舒");
        break;
    case 2:
        System.out.println("温客行");
        break;
    case 3:
        System.out.println("周絮");
        break;
    default:
        System.out.println("张成岭");
        break;
}
/*
switch (){
    case 1:
    ...
    break;  
    case 2:
    ...
    break; 
    ...
    default:
    ...
    break;   
}*/

循环语句：

int num = 1;
while(num<=5){
	num++;
 System.out.print(num+”、”);
}
/*
while (){
    ...
}
*/
int num = 3;
for (int i = 0; i < num; i++) {
System.out.println("i输出值"+i+"、");
}
/*
for (){
    ...
}
*/
int num = 1;
	do {
		num++;
		System.out.print("do..while"+num+"、");
} 
while (num<1);	
/*
do {
    ...
}
while (...);
*/
int a[] = new int[]{1,2,3,4};
for (int a1:a){
    System.out.println(a1);
}
/*
for (总的每一个元素的数据类型 别名：要遍历的总的){
    ...//操作这个别名
}
*/

输入、输出语句：

Scanner s = new Scanner(System.in)；//输入
int i = s.nextInt();
int i = s.nextLine();
int i = s.nextFloat();
int i = s.next();//引用
System.out.println("...");
System.out.printf("...");
System.out.print("...");//输出
/*println->换行；
print/printf->不换行，一行输出！*/
//输入输出语句实例：
Scanner s = new Scanner(System.in);
String next = s.nextInt();
System.out.println(s);

类与对象：

【重要性：继承>多态>封装】

封装

1.通过“private，default，protected，public“关键字实现属性或方法的封装，仅对外提供公共访问方式。

2.通过set/get操作其属性或方法。

3.步骤：（1）修改属性可见性为private；

（2）创建set/get方法；

（3）在set/get方法加入属性控制语句;

4.封装实例：

public class Person{
    private int age;
    public int getAge(){
        return age;
}public void setAge(int age){
    this.age = age;
}
/*this.age = age中左边的this.age -> private int age中的age;
而右边的age -> setAge(int age)中的age;*/

继承：

1.使用extends

2.作用：（1)实现代码的重用；

(2)通过继承实现对现实世界更加准确的建模。

//继承实例
public class Student{
    ...
}
public class Test extends Student{
    ...
}//[extends 父类名]
public class Test implements A{
    ...
}//[implements 接口名]
public class Test extends Student implements A{
    ...
}//[extends 父类名][implements 接口名]

注：Object类是所有类的父类；方法：clone、getClass、toString、equals、hashCode、notify、 notifyAll、wait、finalize。

多态：

1.3个必要条件：继承，方法的重写，父类引用指向子类对象。

2.好处：提高维护性和扩展性。

3.实现方式：接口实现，继承父类进行方法的重写，父类引用指向子类对象，同一个类中方法重载。

类：

//类的实例化 通过new
Student student = new student();
student.setAge = 20;

//创建类(类的定义)->可见继承实例
public class Test[extends 父类名][implements 接口名]{
    ...
}//public 修饰符，可有可无  Test 类名

//类的继承格式
class Parent{
    ...
}//Parent->父类
class Son extends Parent{
    //调用共有(public)
}//Son->子类 Parent->父类

//类大例

class Stu{
//1.属性设为私有
    private int age;
//2.get和set方法
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        ...
    }
//纯自己定义的方法
    public void myPrint(){
        System.out.println("hi");
    }
//3.构造函数->分有参无参两种
    public Stu(){
        ...
    }//无参
    public Stu(int age){
        this.age = age;
    }//有参
}

抽象类、接口：

1.抽象类：类前加关键字abstract修饰

public abstract class A{
    ...
}//可含普通变量，静态变量，公共变量，普通方法，抽象方法

2.接口：接口中所有的定义方法都是抽象的，变量只能为 public、static、final

public abstract void add();
//等效于 void add();

public static final int age = 99;
//等效于 int age = 99;

3.接口与抽象类的区别

接口	抽象类
要被子类实现	要被子类继承
变量全为公共静态变量	可有普通变量
全为方法的声明	可以有方法的实现
不可有构造函数	可以有构造函数
可多实现	必须被单继承
全为抽象方法	可有非抽象方法

方法的重载和重写：

1.当返回值类型为void类型时无return

2.方法定义格式：权限修饰符返回值声明方法名(参数列表){...} （详见类大例或set/get方法实例）

3.重载：（1）在同一个类；

（2）方法名相同；

（3）方法的参数的个数、顺序或类型不同；（三者满足其一就行）

（4）与修饰符或返回值无关；

4.重写：当父类方法无法满足子类需求时

注意事项：（1）重写的方法必须同父类一模一样（返回值类型、方法名、参数列表）

（2)子类的访问权限>=父类的访问权限（public>protected>default>private）

5.关键字：

（1）this关键字只能用在非静态方法

注：静态方法->包含static

（2）super关键字用于子类方法中指向父类对象

super.父类的属性/函数/构造函数/方法

（3）static关键字->方便调用，可通过类名. 变量名/方法名直接引用

（4）final关键字修饰的类不能被继承

修饰的方法不能被重写（但子类可用父类final修饰的方法）

修饰的变量不可变

修饰的引用类型变量，引用不可变，引用对象内容可以变

类型转换：

（从右向左看）

1.向上转型：通过子类实例化父类

Parent parent = new Son();

2.向下转型：通过父类实例化子类

Son son = (Son)parent;

3.调用子类独有方法

class Parent{
...
}
class Son extends Parent{
    public void funcSon(){
        ...
    }
}
public class Tset{
    public static void main(String args[]){
        son.funcSon();
    }
}

构造方法：

public 类名（参数 ->可有参可无参）{...}

public class Person{
    private String name;
    private int age;
    public  Person(){
        ...
    }//无参
    public  Person(String name){
        this.name = name;
    }
    public  Person(int age){
        this.age = age;
    }//有参
    public  Person(String name，int age){
        this.name = name;
        this.age = age;
    }//全参
}
class Test{
    public static void main(String args[]){
        Person person = new Person(name:"周子舒",age:30);
    }
}//比set/get方法更简单

public class Person{
    private String name;
    private int age;
    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;
    }
}
class Test{
    public static void main(String args[]){
        Person person = new Person();
        person.setName("周子舒");
        person.setAge(30);
    }
}//set/get方法实例

数组：

1.一维数组：

int a[] = new int[3]; /*开辟了一个长度为3的数组*/
a[0] = 10;// 第一个元素
a[1] = 20;// 第二个元素
a[2] = 30;// 第三个元素
for(int x = 0; x < a.length; x++) {
	System.out.println(a[x]); //通过循环控制索引
}

2.二维数组：

/*1*/
int a[][] = new int[3][];//前行后列，列可省
a[0] = new int[3];//第0行有3列
a[1] = new int[2];//第1行有2列
a[2] = new int[1];//第2行有1列
//初始化完成
System.out.println(Arrays.toString(a[0]));//将int数组转换成字符串；打印第0行

/*2*/
int a[][] = new int [3][2];//指定3行2列
a[0][1]=1;//第0行第1列是1

/*3*/
int a[][] = new int [][]{{1,2,3,4}{1,2,3}};//{1,2,3,4}->第0行{1,2,3}->第1行

3.常用方法：

查看数组长度：System.out.println(a.length);

两种数组拷贝方法：

int b[ ]=a;
int b[ ] = Arrays.copyOf(a,newLength:2);//自定义长度

数组排序：
Array.sort(a);<默认从小到大>

异常处理：

注：IOException ：受检察异常（非运行时异常）

RuntimeException：不受检察异常（运行时异常）

1.try catch finally

public class ExceptionTest{
    public static void main(String[] args){
        try{
            int a = 10/0;//执行不了，报错，直接跳过接下来try块里语句，执行catch块
            System.out.println("10/0");
        }
        /*try{
            int a = 10/2;
            System.out.println("10/2");
        }//语句未报错，直接跳过接下来catch块，执行finally块*/
        catch (Exception e){
            System.out.println("异常为"+e);
        }//catch抓取报错
        finally{
            int a = 3;
            System.out.println("a的值为"+a);
        }//最后一定会执行，除（System.exit(0); 或此线程为守护线程，而主线程已经死亡）
    }
}

2.throws throw

public void doA(int a) throws Exception1,Exception2{
    ...
}//throws放于方法后面

//-----------------------------------------------------------------------------------------

try{
    ...
}catch(Exception1 e){
    throw e;
}//throw放在catch块里

3.自定义异常（不考）

Java中常用类库：

String类：

1.String类是不可变序列

2.初始化：

String str1 = "HelloWorld";
//第一种初始化方法
String str2 = new String();
str2 = "HelloWorld";
//第二种初始化方法
String str3 = new String("HelloWorld");
//第三种初始化方法

3.String类常见操作：

char charAt(int index)	⭐返回指定索引处的 char 值。
int compareTo(Object o)	把这个字符串和另⼀个对象⽐较。同为0
int compareTo(String anotherString)	按字典顺序⽐较两个字符串。同为0
int compareToIgnoreCase(String str)	按字典顺序⽐较两个字符串，不考虑⼤⼩写
String concat(String str)	⭐ 将指定字符串连接到此字符串的结尾
boolean contentEquals(StringBuffer sb)	当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真
static String copyValueOf(char[] data)	返回指定数组中表示该字符序列的 String
static String copyValueOf(char[] data, int offset, int count)	返回指定数组中表示该字符序列的 String
boolean endsWith(String suffix)	测试此字符串是否以指定的后缀结束
boolean equals(Object anObject)	⭐将此字符串与指定的对象⽐较
boolean equalsIgnoreCase(String anotherString)	将此 String 与另⼀个 String ⽐较，不考虑⼤⼩写
byte[] getBytes()	使⽤平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到⼀个新的 byte 数组中
byte[] getBytes(String charsetName)	使⽤指定的字符集将此 String 编码为 byte 序列，并将结果存储到⼀个新的 byte 数组中
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	将字符从此字符串复制到⽬标字符数组
int hashCode()	返回此字符串的哈希码
int indexOf(char ch)	⭐返回指定字符在此字符串中第⼀次出现处的索引
int indexOf(int ch, int fromIndex)	返回在此字符串中第⼀次出现指定字符处的索引，从指定的索引开始搜索
int indexOf(String str)	返回指定⼦字符串在此字符串中第⼀次出现处的索引
int indexOf(String str, int fromIndex)	返回指定⼦字符串在此字符串中第⼀次出现处的索引，从指定的索引开始
int lastIndexOf(int ch)	返回指定字符在此字符串中最后⼀次出现处的索引
int lastIndexOf(int ch, int fromIndex)	返回指定字符在此字符串中最后⼀次出现处的索引，从指定的索引处开始进⾏反向搜索
int lastIndexOf(String str)	返回指定⼦字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)	返回指定⼦字符串在此字符串中最后⼀次出现处的索引，从指定的索引开始反向搜索
int length()	返回此字符串的⻓度
boolean matches(String regex)	告知此字符串是否匹配给定的正则表达式
boolean regionMatches ( boolean ignoreCase , int toffset , String other , int ooffset , int len )	测试两个字符串区域是否相等
boolean regionMatches(int toffset, String other, int ooffset, int len)	测试两个字符串区域是否相等
String replace(char oldChar, char newChar)	⭐返回⼀个新的字符串，它是通过⽤ newChar 替换此字符串中出现的所有 oldChar 得到的
String replaceAll(String regex, String replacement)	⭐使⽤给定的 replacement 替换此字符串所有匹配给定的正则表达式的⼦字符串
String replaceFirst(String regex, String replacement)	使⽤给定的 replacement 替换此字符串匹配给定的正则表达式的第⼀个⼦字符串
String[] split(String regex)	根据给定正则表达式的匹配拆分此字符串
String[] split(String regex, int limit)	根据匹配给定的正则表达式来拆分此字符串
boolean startsWith(String prefix)	测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)	测试此字符串从指定索引开始的⼦字符串是否以指定前缀开始
CharSequence subSequence(int beginIndex, int endIndex)	返回⼀个新的字符序列，它是此序列的⼀个⼦序列
String substring(int beginIndex)	返回⼀个新的字符串，它是此字符串的⼀个⼦字符串
String substring(int beginIndex, int endIndex)	返回⼀个新字符串，它是此字符串的⼀个⼦字符串
char[] toCharArray()	⭐将此字符串转换为⼀个新的字符数组
String toLowerCase()	使⽤默认语⾔环境的规则将此 String 中的所有字符都转换为⼩写
String toLowerCase(Locale locale)	使⽤给定 Locale 的规则将此 String 中的所有字符都转换为⼩写
String toString()	返回此对象本身（它已经是⼀个字符串！）
String toUpperCase()	使⽤默认语⾔环境的规则将此 String 中的所有字符都转换为⼤写
String toUpperCase(Locale locale)	使⽤给定 Locale 的规则将此 String 中的所有字符都转换为⼤写
String trim()	⭐返回字符串的副本，忽略前导空⽩和尾部空⽩
static String valueOf(primitive data type x)	返回给定data type类型x

StringBuffer类：

1.为方便用户修改字符串内容

2.常用方法：

StringBuffer sb=new StringBuffer();
//创建⼀个空的StringBuffer对象
StringBuffer sb=new StringBuffer(String str);
//接收⼀个String内容并变为StringBuffer内容
public StringBuffer append(数据类型 变量)
sb.append(String str1);
//对StringBuffer内容进⾏连接
public StringBuffer insert(索引，数据类型 变量)
sb.insert(int insert,String str2);
//在指定索引位置插⼊数据
public StringBuffer delete(起始索引，终点索引)
sb.delete(0,2);
//删除指定索引范围的数据
publlic StringBuffer reverse()
sb.reverse();
//内容翻转

System类：

常用方法：

arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
//从指定源数组中复制⼀个数组，复制从指定的位置开始，到⽬标数组的指定位置结束。

src：源数组
srcPos：源数组的起始位置
dest：目标数组
destPos：⽬标数组的起始位置
length：要复制的数组元素的个数

int[] srcArr={10,51,22,31,56}; 
int[] destArr=new int[4];
System.arraycopy(srcArr, 1, destArr, 0, 4);//把srcArr这个数组的元素拷⻉到destArr数组

currentTimeMillis() ：返回以毫秒为单位的当前时间
exit(int status) ：退出虚拟机

 System.exit(1);

gc()：运⾏垃圾回收器
finalize()：如果⼀个对象被垃圾回收器回收的时候,会先调⽤对象finalize()⽅法
getenv(String name) ：获取指定的环境变量值
getProperties() ：获取系统所有的属性

Properties p=System.getProperties();//获取系统所有的属性
System.out.println(p);
p.list(System.out);

getProperty(String key) ：获取指定键指示的系统属性

String value=System.getProperty("os.name");

Runtime类：

常用方法：

freeMemory()：返回java虚拟机中空闲内存

maxMemory()：虚拟机试图使⽤的最多空闲内存

totalMemory() ：返回 Java 虚拟机中的内存总量

Runtime runtime=Runtime.getRuntime();
System.out.println(runtime);
System.out.println("虚拟机空闲内存："+runtime.freeMemory());
System.out.println("虚拟机试图使⽤的最多空闲内存："+runtime.maxMemory());
System.out.println("虚拟机的内存总量："+runtime.totalMemory());

Math类：

Math.abs(-10) // 绝对值

Math.sqrt(X) //计算平方根

Math.cbrt(X) //计算立方根

Math.pow(a, b) //计算a的b次方

Math.max( 1,2 ) //计算最大值

Math.min( 3,4 ) //计算最小值

Math.ceil(X) //接近此数的⼤的整数的值 3.1->4

Math.floor(X) //接近此数的⼩的整数的值 3.1->3

Math.random( )[0,1) //返回一个[ 0，1）的随机数

Math.round(X) //round 四舍五⼊，float时返回int值，double时返回long值

Random类：

1.Random( ) //创建一个新的随机生成数

Random(long seed) //使用单个long种子创建一个新的随机数生成器

2.方法摘要：

protected next(int bits)	生成下一个伪随机数
int next(int bits)	生成下一个伪随机数
boolean nextBoolean( )	返回下一个伪随机数，它是取自随机数生成器序列的均匀分布的boolean值
void nextBytes(byte[ ] bytes)	生成随机字节并将其置于用户提供的byte数组中
double nextDouble( )	返回下一个伪随机数，它是取自随机数生成序列的、在0.0和1.0之间均匀分布的double值
float nextFloat( )	返回下一个伪随机数，它是取自随机数生成序列的、在0.0和1.0之间均匀分布的float值
double nextGaussian( )	返回下一个伪随机数，它是取自随机数生成序列的、呈高斯（“正态”）分布的double值，其平均值是0.0，标准差是1.0
int nextInt( )	返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的int值
int nextInt(int n)	返回一个伪随机数，它是取自随机数生成器序列的、在0（包括）和指定值（不包括）之间均匀分布的int值

/*默认*/
Random random = new Random();//返回[ 0,1 )
/*如果想要返回[0,100]之间的随机数 可以使⽤:*/
 Random random=new Random(101) //[0,101)->[0,100]

包装类：

1.数据类型-->包装类型（数据类型首字母大写即可得到包装类型）

基本数据类型	包装类型
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

Integer i = 8;//8是int类型
//⾃动装箱(⾃动基本数据类型->包装类型转换)
int m = i;
// ⾃动拆箱(⾃动包装数据类型->基本类型转换)

到这基本就结束啦~

有问题可以私信，虽然我也可能不大会，但是可以一起讨论^_^

资料整理不易，满意的话记得点赞收藏加关注哦！

NEMO不爱敲代码

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java程序设计实践课程（主编：潘浩）重点整理

《Java程序设计教程》潘浩期末复习整理期末复习总结自用大家也可以看看，欢迎私聊讨论！
复制链接

扫一扫

专栏目录

Java程序设计实践课程（主编：潘浩）重点整理

基础知识：

选择语句：

循环语句：

输入、输出语句：

类与对象：

封装

继承：

多态：

类：

抽象类、接口：

方法的重载和重写：

类型转换：

构造方法：

数组：

异常处理：

Java中常用类库：

String类：

StringBuffer类：

System类：

Runtime类：

Math类：

Random类：

包装类：

“相关推荐”对你有帮助么？