java 学习笔记 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;
        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();




}