第一次的学习任务总结
开始学习了如何使用idea和idea优化对编译界面的文字,背景颜色的选择和如何建立Java文件首先先建立Module->Project Structure设置jdk之后建立package->scr->java class完成建设了第一个java class。
学习知识点
注释
三种注释表示
// 单行注释:可以注释一句话
/*
多行注释:可以注释一段文字
*/
/*
*文档注释
*/
标识符和关键字
标识符
- 所有标识符都应该以字母(A~Z或者a ~ z)美元符($),或者下划线(_)开始
- 首字符之后可以是字母(A~Z或者a ~ z)美元 符($),或者下划线(_)和数字组合
- 不能使用关键字作为变量名或方法名。
- 标识符大小写敏感。
- 合法标识符有:abc ,$asjdk,_sdhk,_231
- 不合法标识符有:123abc,-sdhfj
关键字
数据类型
数据类型
四种基本数据类型
int a;//整型类型变量定义
char b;//字符类型变量定义
double c;//浮点类变量定义
boolean d;//布尔型变量定义 只有两种赋值 true or false
类型转换
低 ----------------------------------------------------------------------->高
byte,short,char-> int -> long -> float -> double
- 运算中,不同类型的数据先转化为同一类型(运算类型中最高类型),然后进行运算
- 强制类型装换(转换时会有精度缺失)
int a = 0;
System.out.println((double) a);//将int 类型强制转换为 double 输出结果为0.000000
-
自动类型转换(如在只有 byte 类型运算时结果自动转换为 int 类型)
变量 -
类变量 static 变量名;
-
局部变量 定义在方法里面
…
运算符 -
算术运算符
操作符 | 描述 | 例子 |
---|---|---|
+ | 加法 | A + B |
- | 减法 | A - B |
* | 乘法 | A * B |
/ | 除法 | A / B |
% | 取余 | A % B |
- - | 自减 | A - - 或 - - A |
++ | 自增 | A ++ 或 ++ A |
= | 赋值(A=b将b的值赋值给A) | A = b; 或 A = 0; |
== | 等值 | A = = B |
- 位运算符
& , | ,^ ,~ ,<< , >> ,>>>
- 扩展赋值运算符
- 关系运算符
== ,!= ,> ,< , >= , <=
- 逻辑运算符
&& , || ,!
- 三目运算符
int a ;
(a == 0 )? true:false;
算法结构
- 顺序结构
java的基本结构,按照顺序一句一句的执行下去 - if选择结构
if单选择结构
if (布尔表达式){
//布尔值为true则执行语句
}
if双选择结构
if (布尔表达式){
//布尔值为true执行该语句
}
else{
//布尔值为false执行该语句
}
if多选择结构
if (布尔表达式1){
//布尔表达式1值为true执行该语句
}
else if (布尔表达式2){
//布尔表达式2值为true执行该语句
}
else if (布尔表达式3){
//布尔表达式3值为true执行该语句
}
else {
//如果以上布尔表达式都不为true执行该语句
}
if嵌套选择结构
if (布尔表达式1){
//布尔表达式1值为true执行该语句
if (布尔表达式2){
//布尔表达式2值为true执行该语句
}
}
else {
//如果以上布尔表达式都不为true执行该语句
if (布尔表达式3){
//布尔表达式3值为true执行该语句
}
}
- Switch选择结构
switch (expression){
case value:
//语句
break;//可选
case value:
//语句
break;//可选
//可以有任意数量的case语句
default://可选
//语句
}
- While Do-while循环
while (布尔表达式){
//如果布尔表达式为true则循环
}
Do-while会先执行一次在判断循环条件
do {
//循环体
} while (布尔表达式)//如果布尔表达式为true则循环
- for for-each循环
for (初始值;布尔表达式; 更新(i++)){
//循环语句
}
int a[];
for (int i : a) {
//循环语句
//for-each对a[]数组依次遍历赋值给 i;
}
break
在任何循环语句的主体部分,均可用break控制循环的流程,break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)。
continue
使用在循环语句体中,用于终止某次循环过程,及跳过循环中尚未执行的语句,接着进行下一次是否执行循环的判定。
方法
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
方法的定义
方法(实参);
修饰符 返回类型 方法名 (形式参数类型 参数名){
...
//方法体
...
return 返回值;
}
代码说明
import java.util.Arrays;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] a = {32,3,14,64,6,789,464,789,11,2,556,3,4};
sort(a);
System.out.println(Arrays.toString(a));
}
//冒泡排序
public static void sort(int[] array) {
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] < array[j]) {
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
}
方法的重载
- 方法名称必须相同
- 参数列表必须不同(个数不同,类型不同,参数排列顺序不同等)
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
代码实现
public class Demo01 {
public static void main(String[] args) {
int sum = add(1, 2);
System.out.println(sum);
}
public static int add(int a,int b){
return a+b;
}
public static double add(int b,double a){
return a+b;
}
public static int add(int a,int b,int c){
return a+b+c;
}
public static double add(double a,int b){
return b+a;
}
}
可变参数
在方法的声明中,在指定参数类型后加一个省略号(…)
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何普通的参数必须在它之前声明
public static double add(double...numbers){
double sum = 0;
for (int i = 0; i < numbers.length; i++) {
sum = sum +numbers[i];
}
return sum;
}
递归
就是自己调用自己
递归结构包括:递归头,递归体。
public static int f(int n){
if (n == 1){
return 1;
}
else{
return n*f(n-1);
}
}
数组
相同类型数据的有序集合
int[] a = new int[size];
int a[] = new int[size];
a.length;//数组长度
//静态初始化
int[] a = {...}//初始化
//动态初始化
int[] a = new int[10];
a[0] = 1;
a[1] = 2;
四个基本特点
- 数组一旦被创建,大小不可改变,长度确定
- 元素必须是相同类型,不允许出现混合类型
- 数组元素可以是任何数据类型,包括基本类型和引用类型
- 数组变量属于引用类型,数组也可以看成是对象
二维数组和稀疏数组的使用
public class ArrayDemo04 {
public static void main(String[] args) {
//稀疏数组
int[][] array =new int[11][11];
array[1][2] = 1;
array[2][3] = 2;
//输出原始数组
System.out.println("======================");
System.out.println("输出原始数组");
for (int[] ints : array) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
//转化为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(array[i][j] != 0 ) {
sum++;
}
}
}
System.out.println("有效值的个数"+sum);
//2.创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,转为稀疏数组
int count =0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] =array[i][j];
}
}
}
//输出稀疏数组
System.out.println("======================");
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
}
//
System.out.println("======================");
System.out.println("还原稀疏数组");
int array3[][] = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i <= count; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
for (int[] ints : array) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
面向对象
对于描述复杂的事物,为了宏观上把握,整体上合理的分析,我们需要面向对象的思路来分析整个系统。但是具体到微观操作,仍然需要面向过程的思路去处理
面向对象编程的本质是:一类的方式组织代码,一对象的组织(封装)数据
三大特性:
封装
继承
多态
对象是具体的。类是抽象的,是对对象的抽象
类与对象的创建
public class Student {
//属性
public String name;
public int age;
public void study(){
System.out.println(this.name + "在学习");
}
}
//类,抽象的,实例化
//类实例化后会返回一个自己的对象
//student对象就是一个student类的具体实例
Student student = new Student();
student.name = "小明";
student.study();
构造器
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的,并且构造器有一下两特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
有参和无参构造器
public class Student {
public Student() {
}
public Student(String can) {
}
}
封装
高内聚,低耦合
通过,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏
作用:
1.提高程序的安全性,保护数据
2.隐藏代码的实际细节
3.统一接口
4.系统可维护增加了
public class Student {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
继承
本质是对某一批类抽象,为了更好的建模
extands的意思是“扩展”,子类是父类的扩展
继承是类和类之间的一种关系,除此之外,类和类之间的关系还有依赖,组合,聚合等
public class Student extends person {
}
public class person {
public void say(){
System.out.println("son");
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
Super
super注意点
1.super调用父类的构造方法,必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中!
3.super和this不能同时调用构造方法!
Vs this:
代表的对象不同
this:本身调用者这个对象
super:代表父类对象的应用
前提
this :没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this():本类的构造
super():父类的构造!
public class person {
protected String name ="小明爸爸";
}
public class Student extends person {
private String name ="小明";
public void text(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.text("xiaoming") ;
}
}
方法的重写
子类的方法和父类必须一致;方法体不同!
需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.修饰符,范围可以扩大但不能缩小:public > protected > default > private
4.抛出异常:范围,可以缩小,但不能扩大:ClassNotFoundException—>Exception(大)
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
多态
可以实现动态编译:类型
即同一方法可以根据发送对象的不同而采用多种不同的行为方法
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
s2.run();
s1.run();
((Student) s2).eat();
s1.eat();
}
}
注意事项
1.多态是方法的多态,属性没有多态
2.父类和子类有联系,类型转换异常ClassCastException!
3.存在条件:继承关系,方法重写,父类应用指向子类对象
static方法,属于类,不属于实例
final常量
private 方法
instanceof和类型转换
用于判断两个类之间是否有关系或联系
父类引用指向子类的对象
把子类转换为父类,向上转型
把父类转换为子类,向下转型,强制转换
方便方法的调用,减少重复的代码!
static关键字
public class Person {
{
System.out.println("匿名代码块");
}
static {
System.out.println("静态代码块");
}
public Person() {
System.out.println("构造方法");
}
}
抽象类
1.不能new这个抽象类,只能靠子类去实现它:约束
2.抽象类中可以写普通方法
3.抽象方法必须在抽象类中
public abstract class Student extends person{
}
public abstract class person {
public abstract void dosomething();
}