第一次的学习任务总结
开始学习了如何使用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();
}
4376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
