第一次学习总结
注释
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;
else
return 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 + insert
3.统一接口 set,get
4.系统可维护增加
*/
public class Student {
private String name;
private int age;
private int id;
//set,get方法可以提供为public
public 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 {
@Override
public 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 );//true
Sytem.out.println(Person instance of String );//false
public 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();
}