JAVA 编程语言基础笔记

第一次学习总结

注释
标识符和关键字
数据类型
类型转换
变量
运算符
用户交互scanner
结构类型
break continue
何谓方法
方法的重载
可变参数
递归
数组
java内存分析
多维数组
Arrays类
冒泡排序
稀疏数组
静态方法与非静态方法
面向对象
- 类与对象的创建
- 封装
- 继承
- 多态
- 类型转换
- 抽象类

注释

java的注释有三种：
1.单行注释
使用 // 符号在后面添加要注释的文字

2.多行注释
使用 /* */ 在符号中添加注释文字

3.文档注释
使用 /** */这样每次换行注释时前面会有一个 * 号，前面加个@符号可以表明各种类型，比如：
@author 表明作者的名字

标识符和关键字

标识符
java所有的组成部分都需要名字，类名，变量名，以及方法名都被成为标识符。

所有的标识符都应该以字母，美元符或者下划线（_）开始，首字符过后可以是字母，美元符，下划线或者数字。
标识符大小写是区分的，不是相同的
可以使用中文名，但不建议

关键字
关键字不能用于变量名或者方法名
下面是一些常见的关键字

数据类型

Java有两大数据类型分别是：基本类型和引用类型

字节
*位（bit）：位是计算机内部 数据存储 的 最小单位，
*字节（byte）：字节是计算机中 数据处理 的 基本单位
1B（byte） = 8bit

1bit代表1位，一个byte代表一个字节
1KB=1024B
1M=1024KB
1G=1024M
1T=1024G

类型转换

double>float>long>int>char,short,byte
强制类型转换--------高->低
double j = 1.00;
int i = (int)double;

自动类型转换--------低到高
int i = 1;
double j = i;

变量

变量是可以变化的量，但一定要定义类型
java变量是程序是最基本的存储单元，其要素包括变量名，变量类型，变量域
变量声明是一条完整的语句，所以一定要用 ; 分号结尾
局部变量

public static void main(String []args)
{int i = 0;
//局部命名
}

全局变量

public class Demo01{//static 类变量
static final double  PI = 3.1415926;
}

变量命名规范

类成员变量：首字母小写和驼峰原则
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则

运算符

基本运算符：+,-,*,/,%,++,–
赋值运算符：=
关系运算符：>,<，>=,<=,!=,==
逻辑运算符：&&，||，！
三元运算符：？：
x ？ y : z
如果x==true，则结果为y，否则为z

位运算符
A = 0011 1100
B = 0000 1101
------------------------
A&B 0000 1100
A|B 0011 1101
A^B 0011 0001
~B 1111 0010
<< 左移 2 2222
>> 右移 /2
2<<3(2向左移3位)
0000 0010-----2
0001 0000-----16

用户交互scanner

import java.util.Scanner;public class Demo01 {public static void main(String[] args) {//创建一个扫描对象，用于接收键盘数据Scanner scanner = new Scanner(System.in);System.out.println("使用next方式接收：");//判断用户有没有输入字符串if(scanner.hasNext()){//使用next方式接收String str = scanner.next();System.out.println("输出的内容为："+str);}scanner.close();//关闭节省空间}
}

next()不能得到带有空格的字符串
nextline（）可以得到带有空格的字符串
用scanner输入时定义的变量，scanner也要强调变量的数据类型

double f = scanner.nextDouble();

结构类型

顺序结构

java的基本结构就是顺序结构，任何一个算法都离不开顺序结构，语句从上到下运行
if选择结构

if(布尔表达式)
{//如果布尔表达式为true执行
}

if双选择结构

if(布尔表达式)
{//如果布尔表达式为true执行
}
else
{//如果布尔表达式为false执行
}

if多选择结构

if(布尔表达式)
{//如果布尔表达式为true执行
}
else if(布尔表达式)
{//如果布尔表达式为true执行
}
else if(布尔表达式)
{//如果布尔表达式为true执行
}
else
{//如果以上布尔表达式都不为true
}

switch选择语句

public class SwitchDemo01 {public static void main(String[] args) {String s = "厉害";switch(s){case "优秀":System.out.println("优秀");break;case "厉害":System.out.println("厉害");break;case"不错":System.out.println("不错");break;default:System.out.println("haha");}}

循环结构

while循环
do …while循环
for循环

while循环

while（布尔表达式）
{//只要结果为true就一直循环下去
//我们需要一个让表达式失效的方法结束循环，break可以强制结束
}

do…while循环

do{//先执行，再判断布尔表达式，最少执行一次循环中的语句
我们需要一个让表达式失效的方法结束循环，break可以强制结束
}

for循环

for(初始化；布尔表达式；更新)
{//代码语句
}

for循环增强

   int[] array = {1,2,3,4,5};for(int x : array)System.out.println(x);//数组中的每个元素复制给X再输出

break continue

break
在任何循环语句的主体部分，均可用break控制循环流程；break用于强行退出循环，不执行循环中剩余的语句
continue
continue用于循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，进入下一次循环的判定

何谓方法

Java语句是语句的集合，他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中别创建，在其他地方被引用
- 设计方法时最好保证一个方法执行一个功能

修饰符 返回值类型 方法名（参数类型，参数名）{...
//方法体
return 返回值;//return 0 表示结束方法
}

例

main方法

   public static void main(String[] args) {}

add方法

public void add(int a,int b){//传入参数System.out.println(a+b);//输出后换行System.out.print();//输出后不换行return a+b;
}

若返回值类型前面加了static，则在引用该方法时需新建一个变量再引用
方法调用

调用方法：对象名.方法名（实参）
当方法返回一个值时，方法调用被当成该值
如果方法返回值是void，方法调用一定是条语句

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载规则

方法名称必须相同
参数列表必须不同（个数不同，或类型不同，或排列顺序不同）
方法的返回值类型可以相同也可以不同
仅仅返回类型不同不足以构成方法的重载

可变参数

在方法声明中，在指定参数类型后加一个省略号…
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明

public class Demo02 {public static void main(String[] args) {Demo02 demo02 = new Demo02();demo02.test(1,2,3,4,5);}public void test(int... i){System.out.println(i[0]);System.out.println(i[1]);System.out.println(i[2]);System.out.println(i[3]);}
}

递归

递归就是A方法调用A方法，自己调用自己

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法

public class Demo03 {public static void main(String[] args) {System.out.println(f(5));}public static int f (int n){if(n == 1)return 1;elsereturn n*f(n-1);}
}

数组

数组的定义

数组是相同类型数据的有序集合
数据描述的是相同类型的若干个数据，按照一定的次序排列组合而成
每一个数据称作数组元素，每个数组元素可以通过下标访问它
数组声明创建

datatype[] arayfVar;//Java首选
datatype arayfVar[];//效果相同
datatype[] arayfVar = new dataType[arraySize];
]

获取数组长度
arrays.length
数组的特点

长度是确定的，一旦创建大小不可以改变
元素必须是相同类型
数组元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用对象，数组本身就是对象，java中对象是在堆中的
数组边界
下标的合法区间，：[0,length-1],如果越界就会报错

java内存分析

三种初始化

* 静态初始化
int a[] = {1,2,3}动态初始化
int a[] = new int[2];
a[0]=1;
a[1]=2;
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间，其中每个元素也被实例变量默认初始化

多维数组

多维数组可以看成是数组的数组，比如二位数组就是一个特殊的一维数组，其中每一个元素就是一个数组

Arrays类

import java.util.Arrays;
//Arrays数组各种函数的运用
public class Demo03 {public static void main(String[] args) {int[] a = {15,43,56,76,87,23,435};System.out.println(Arrays.toString(a));//输出数组类型printArray(a);Arrays.sort(a);//数组排序System.out.println(Arrays.toString(a));//Arrays.fill(a,0);//数组填充//System.out.println(Arrays.toString(a));Arrays.fill(a,2,5,0);//指定位置填充(2,5左闭右开）System.out.println(Arrays.toString(a));}public static void printArray(int[] b){for (int i = 0; i <b.length ; i++) {if(i == 0)System.out.print("[");if(i == b.length-1)System.out.println(b[i]+"]");else{System.out.print(b[i]+", ");}}}

冒泡排序

import java.util.Arrays;
//冒泡排序
public class Demo04 {public static void main(String[] args) {int[] a = {3,56,64,76,123,45,787,34};int[] c;c = sort(a);System.out.println(Arrays.toString(a));}public static int[] sort(int[] b){int d = 0;for (int i = 0; i < b.length-1; i++) {//下方j+1，所以需要length-1，否则会爆表boolean flag = false;//如果有序则不比较，减小比较的次数for (int j = 0; j < b.length -1- i; j++) {if (b[j + 1] < b[j]) {d = b[j+1];b[j+1] = b[j];b[j] = d;flag = true;}}if(flag == false){break;}}return b;}

稀疏数组

当一个数组中大部分元素是0，或者大部分元素相同，用稀疏数组来保存。
稀疏数组的处理方法：

记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素和行列记录在一个小规模数组中

public class Demo05 {public static void main(String[] args) {int[][] array = new int[11][11];array[1][2] = 1;array[2][3] = 2;for (int[] ints : array) {for (int anInt : ints) {System.out.print(anInt+"\t");}System.out.println();}System.out.println("======================");//               稀疏数组int num = 0;for (int i = 0; i < 11 ; i++){for (int j = 0; j < 11; j++){if (array[i][j] != 0){num++;}}}int[][] array2 = new int[num+1][3];int count = 0;array2[0][0] = 11;array2[0][1] = 11;array2[0][2] = num;for (int j = 0; j < array.length ; j++) {for(int k =0 ;k < array[j].length;k++){if(array[j][k]!=0){count++;array2[count][0] = j;array2[count][1] = k;array2[count][2] = array[j][k];}}}for(int[] a : array2){for (int b : a){System.out.print(b+"\t");}System.out.println();}}

静态方法与非静态方法

定义类时如果加了static，别的类调用时不需要新建对象引用；如果没加static则需要新建对象引用。

面向对象

面向过程适合解决简单的问题，按照步骤一步步解决，面向对象是将问题分为多个类，然后分别对着类解决。

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据

三大特性：封装，继承，多态

类是抽象的而对象是具体的事物，类是对象的模板

类与对象的创建

类是一种抽象的数据类型，它是对某一类事物整体描述，但是并不能代表某一个具体的事物

对象是抽象概念的具体实例

类的定义

//定义了一个人的类
public class Person{String name；int age;//属性//方法
public void Study(){}
}

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间外，还会给创建的对象默认初始化以及对类中构造器的调用
类中构造器也称构造方法，是在进行创建对象时必须调用的，并且构造器还有以下两个特点
1 必须和类的名字相同
2 必须没有返回类型，也不能写 void

public class Person{public Person(){}//构造器创建}

public static void main(String[] args) {Person person = new Person（）
//类实例化后会返回自己的一个对象
//person对象就是Person类的具体}

创建对象内存分析

封装

封装是数据的隐藏，通常，禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问。
属性私有，通过 get/set 访问

//private只能自身调用(属性私有)
// ，public对外/*            封装1.提高程序的安全性，保护数据2.隐藏代码的实现细节  alt  + insert3.统一接口 set,get4.系统可维护增加*/
public class Student {private String name;private int age;private int id;//set,get方法可以提供为publicpublic String getName(){return this.name;}public void setName(String name){this.name = name;}//alt   +   insert直接生成方法public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

继承

继承的本质是对某一些类的抽象，从而实现对现实世界的建模。
extends 是“扩展”；子类是父类的扩展。
Java中只有但继承，没有多继承，子类继承父类用 extends 表示
所有的类都继承object类

//Ctrl  +  H  可以看到继承关系
/*继承子类可以继承父类的属性和方法但private不可继承所有的类都继承object*/
public class Person{String name;int age = 10;
public void say(){System.out.println("优秀")
}   }

public class Student extends Person{Student student = new student()
student.say();
int b =sudent.money;
}

方法重写

public class A extends B {@Override//重写public void test() {System.out.println("test->A");}
}

public class B {public  void test(){System.out.println("test->B");}
}

public class Application {/*重写：   子类重写父类的方法* 1.需要有继承关系，方法名必须相同* 2.参数列表必须相同* 3.修饰符，范围可以扩大，不可缩小  public>protected>default>private* 不可以使用private* 4.抛出的异常只能缩小，不可以增大*/public static void main(String[] args) {//静态的方法与非静态方法差别很大//静态：方法的调用只和左边的数据类型有关//非静态：重写A a = new A();a.test();//父类的引用指向了子类B b = new A();//子类重写了父类的方法b.test();}

多态

public class Person {public void say(){System.out.println("hello");}}

/*
*单继承时父类不能使用子类的方法，但子类可以使用父类的方法
* 但重写时，父类能够使用子类的方法，因为重写是子类改写父类的方法*///       多态
/**多态是方法的多态，属性没有多态* 父类和子类有联系* 需要继承，并且方法需要重写但重写 static，final,private 不可以重写*/public class Student extends Person {@Overridepublic void say() {System.out.println("good");}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 Object();s1.say();s2.say();}
}

类型转换

instance of 只有在两个类存在父子关系才可以使用

public class Person{}

public class Student extends Person{Person person = new Student();Sytem.out.println(Person instance of Student );//trueSytem.out.println(Person instance of String );//falsepublic void go(){}}

public class Application{Person obj = new Student();(Student(obj).go());//Student student = (Student) obj;//student.go();}

抽象类


//抽象类
public abstract class Action {//抽象方法,只有方法名字，没有方法实现/*抽象类中可以定义普通的方法，但抽象方法必须在抽象类中*/public abstract void say();}