java基础的笔记

来源：互联网发布：mac与虚拟机共享文件编辑：程序博客网时间：2024/04/30 13:19

“{ }”是一个作用域，存放类体，用于编写属性，方法，写在类体的括号之间。

()参数作用于

Main方法是Java的主函数，main之后的{}叫做方法体

{

可以写方法的操作逻辑，方法体不能写方法，但是可调用别打方法。

}

八大基本数据类型

整型

Int 整型

Byte 字节型

Short 短整型

Long 长整型

实数型

Float 单精度浮点型

double 双精度浮点型

布尔类型

boolean true and false

字符型 Char 16 bit

引用数据类型

数组，类，接口

基本数据类型的转型

1>:auto转型

基本数据类型的从小到大排序

Byte -->short(char)-->int -->long-->float-->double

2>:强制转型

Java 变量命名规则

首字母必须小写(字母，下划线，”$”)+其他部分(数字，字母，下划线，”$”)

例：int _$22_

Java 的方法

普通方法和构造函数

普通方法：

[修饰符]+[返回类+void]+[方法名(首字母小写)]([参数]){

逻辑操作的地方

}

例:public void test(){int a=0;

}

A++

++位置在后，表示先调用，再+1；

++a

++位置在钱，表示先+1，再调用

//关系运算符：>

//= 表示赋值 ==：表示判断

boolean b = 10==10;

System.out.println( "10>9 ? :" +b );

// &:与，表示两边的boolean判断都是true才为true

// |:或。表示两边的boolean判断只要有一边是true，为true ，否则false

// ^:且表示两边的boolean 不一致，为true

// ! 非：表示跟boolean判断相反，false为true，true为false

//特殊的与：带阻断的与和带阻断的非

boolean i=true,j=false;

boolean or=i|j,and =i&&j;

System.out.println("or "+or);

System.out.println("and "+and);

System.out.println(false&true);

System.out.println( true|false);

System.out.println( true^true);

System.out.println( !false);

System.out.println("带阻断的与："+( false&&true));

System.out.println("带阻断的非："+ (false||true));

}

脚标：0,1

String student []={“张三”，”李四”}

控制流语句的类型

判断语句

If-else

Swich-case

Scanner sn=new Scanner(System.in);

int a=sn.nextInt();

if (a%5==0&&a%6==0) {

System.out.println("可以被5和6同时正除");

} else if(a%5==0^a%6==0){

System.out.println("至少能被5或6整除");

}

switch (btype) {

case 0:

System.out.println(a+" + "+b +"="+(a+b));

break;

case 1:

System.out.println(a+" - "+b +"="+(a-b));

break;

default:

break;

}

For循环语句

While循环

Do-while循环

For循环

public static void whileTest(){

// while(条件是否成立){成立执行} 不成立就跳出当前的循环

int count = 0 ; //当 count =1000 停止当前的顺环

while(count>=0){

if (count==100) {

// 停止的关键字 break return continue

// break; // 跳出当前的顺环

/* try { Thread.currentThread().sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();}*/

// continue; // 终止当次的顺环，下面的操作就不会执行

return ; //是跳出该方法，方法之后的逻辑操作都没有执行

}else{

System.out.println("count 的值："+count); }

count++;

}

System.out.println("顺环执行结束 ");

}

Char chars[]={‘a’,’b’,’c’,’d’,’e’};

Int i=0;

Do {

语句块

System.out.println(" "+chars[i++]);

} while (

条件

I<chars.length

)

数组

数组是一个变量，用于将相同数据类型的数据存在存储单元中

可以使用3种方式声明数组：

数据类型标识符[];

数据类型标识符 []=new 数据类型[大小]

数据类型标识符 []={值1,值2,...值n}

数组可以多维

一维数组

Int numbers []=new int [10]

二维数组

Int classid [][]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}

//4个一维，1维的长度

Int classid [][]=new int [3][2]

三维数组

Int schools[][][]={

{{1,2,3},{4,5,6}},

{{7,8,9},{10,11,12}},

{{13,14},{15,16}}

}

四维数组

以此类推，规律就是由0--n个三维组成

5,6,7，以此类推、

排序

Arrays.sort(n);

for (int i : n) {

System.out.print(i + " ");

}

GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

转义符

转义符的使用

\\u0024

Java-oop 面向对象

对象实体：new:创建 +类名()；

声明对象：Car car=null；

实例化对象：car=new Car()；

构造器

public Employee(String name, double salary, int year, int month, int day) {

this.name = name;

this.salary = salary;

GregorianCalendar calendar = new GregorianCalendar(year, month, day);

hireDay = calendar.getTime();

}

构造器与类同名

每个类可以有一个以上的构造器

构造器可以有0个以上的参数

构造器没有返回值

构造器总是伴随着new 操作使用

状态-->抽象-->变量(属性)

Public String name;

--行为-->抽象-->方法

Public void tets(){

syso

}

方法重载

Public void test(){

}

Public void test(int age){

}

Public void test(int age,String name){

}

Void 表示没有返回值.如果有返回值，写上返回值的类型=

Public int buy(){

Return 10;

}

访问修饰符

Public 公共 friendly 友好 private 私有

This关键词的使用

Public String name;

Public int age;

一个类名

Class Student {

Public Student (){//构造方法

}

Public Student (String name,int age){//构造参数

//this关键字，代表类的实体

This.name=name;

This.age=age;

}

Public void study(){

System.out.print(name + " + "+age);

}

继承

Super

Super()只能写在第一行。

方法修饰符

static 静态的方法可以直接调用，而实例方法需要用到new;

1.修饰变量,表示这是个静态变量(类变量)直接通过类名调用

2.修饰方法,表示这个是静态方法或者叫做类方法,直接通过类名调用
Text t=new Text();
t.方法或者属性;

final

1.修饰变量 public final String canme=”name”;

表示是常量，必须进行初始化赋值，如果没初始化，则必须在构造器中赋值

2.修饰方法，表示不能被子类方法重写

public Vhicle(){

name="name";

}

3.修饰类，表示该类不能被继承

public final class Car(){

}

Abstract

Public abstract class Father{

Public abstract void test();

}

其他的类继承test抽象类。

Interface

接口：某个事物对外提供的一些功能的申明

可以利用接口实现多台，同时接口也弥补java单一集成的弱点

一般使用接口声明方法或常量，接口中的方法只能是声明，不能使具体的实现

接口的实现可以继承1...N个接口。

Extends

只能继承一个

private int a = 10;

int m = 12;

static int n=1;

kaijiang t = new kaijiang ();

System.out.println(t.m);

/*在空格处如下哪个使用是错误的？（B）

A) t.a

B) this.m

C) t.m

D) T.n*/

=============================================================

String st1=”hello”;//直接赋值

String st2=new String (“hello”);//通过new赋值

String st3=st2;//传递引用

使用”==”比较字符串的内容

System.out.println("st1==st2 :"+(st1==st2));

System.out.println("st1==st3 :"+(st1==st3));

System.out.println("st2==st3 :"+(st2==st3));

结果如下：

st1==st2 false

st1==st3 false

st2==st3 true

栈内存堆内存

Str1 String st1=”hello” ---> “hello” 0x1001

Str2 String st2=new String (“hello”); --> “hello” 0x1002

Str3 String st3=st2; --> “hello” 0x1002

对st1跟st2来说，其内容分别保存在不同的空间，所以内容相等，地址的值也是IBU相等的。”==”是用来进行数值比较的，所以st1 and st2比较是不相等的。

St3 and st2的地址值是相等的，因此总结得出”==”是用来进行地址值比较的。

使用equals进行比较字符串的内容

则全部都为true

声明的字符串内容相同，则不会再出现新的栈内存空间。

其中涉及到栈内存跟堆内存的内容

栈内存堆内存

Str1 hello 0x0001

Str2

Str3

面向对象的程序设计有封装性,多态性,继承性

有抽象方法的类一定是抽象类

抽象类里不一定有抽象方法

抽象方法只需生命而不需要实现

抽象类必须被子类继承.

一个抽象类可以使用final 关键字声明吗?

答:一个类如果使用了final关键字声明,则此类不能被子类继承,而抽象类又必须被子类重写,所以一个抽象类不能使用final 关键字声明.

一个抽象类中可以定义构造方法吗?

答:一个抽象类中是允许存在构造方法的,因为抽象类依然使用的是类的继承关系,而且抽象类中也存在各个属性,所以子类在实例化之前必须先要对父类进行实例化.

在使用abstract 关键字修饰抽象方法时不能使用private修饰,因为抽象方法必须被子类重写,如果使用了private声明,则子类是无法重写的.

0 0