“{ }”是一个作用域,存放类体,用于编写属性,方法,写在类体的括号之间。
()参数作用于
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声明,则子类是无法重写的.