java基础(一)

类与对象

 类是一类物体的抽象，它只是在定义，不是具体的东西，对象才是具体的东西

 public class student{

 //定义一个int类型的字段

 int  age = 18;

  }

public class test{

public student void main(String[] args){

student fl = new studrnt();

System.out.println(zs.age);

}

 }

类

一、一个类里面包含两个方面：

1、属性：字段（访问修饰符  数据类型    变量名称  =  初始值）

1）、两个修饰符：public(公共的)  private（私有的）

2、功能：方法

1）、方法

public  void  student( ){  ................... }

访问修饰符 返回值 方法名（参数类型 参数名，参数类型 参数名）{方法体}

访问修饰符：控制方法的访问范围

返回值：这个方法的结果

方法名：调用方法用的名字

参数列表：调用方法的者给这个方法传递的参数，可以多个

方法体：具体这个方法实现的功能

对象

对象是一个具体的东西

 一、创建对象

 Student s = new Student();//创建一个叫sr的学生对象 

1）s：保存在栈空间中

2）new Student():保存在堆空间中

3）.=;起子指向的作用

4）如果建了一个无用的对象时，java中的垃圾回收机制会去处理掉这个无用对象，不用我们去处理

 堆栈

栈：内存小，速度快

堆：内存大，速度慢

速度不同的原因，是因为堆和栈内部结构的原因，栈空间的储存结构固定，只能保存比较简单的数据，堆空间不固定，可以保存各种各样的数据，这就是速度不同的原因

   无参构造函数

 一、构造方法：构造对象时用于new后面的方法

假如没有给类定义构造函数，就表示有一个默认的构造函数--无参构造，方法体中没有代码

构造方法与变通方法的区别：没有具体写明返回值，因为他肯定返回的是这个类的对象 

创建对象时，类中代码执行的顺序

1、static最早的（static代码块，static变量，块和变量执行顺序就是从上到下进行书定的）

 2、变通变量（同时还包含了变通代码块，块和变量的执行顺序就是从上到下进行书写的）

 3、最后才是构造函数     

static

1.static 的变量和代码块，只执行一次，这个类第一次被执行（或者说，是这个字节码数据加载到虚拟机中时，创建的变量和执行静态的代码块）

2.变通变量可以面向所有对象 ，静态变量只能一个对象，因为它只有一个对象，所以属于这个类的对象 

3.静态方法，不需要使用对象来调用，因为静态方法和静态属性一样，是属于类的，不属于具体某个对象 

 数据类类型

 一、基础数据类型：8种

char:字符类型

boolean:真假类型，true, false

byte:一个字节，整数

shout:两个字节，整数

int:四个字节，整数

long:八个字节，整数

flaot:四个字节，小数

double：八个字节，小数

保存方式：由于基础数据类型结构简单，所以保存在栈中

 二、复杂数据类型

 除去基础数据类型个，其他都 是复杂数据类型

 最大值和最小值

 byte是一个字节，一个字节有八位，由八个01组成，有256种表示方法，由于第一位表示符号，所以表示值得是后面7位，又因为0是自然数 ，那么这个值的范围是-128到127

     值传递和引用传递

 基础数据类型是值传递，复杂数据类型是引用传递

String是不可变字符串，所以传递后，去修改，不能修改到原来的字符串对象，如果一定要修改字符串，可以用StringBuffer代替

方法的重载

在一个类中，方法名相同，参数列表不同（不是变量名不同而是变量类型不同），返回值 类型跟重载没有关系

public int suanjiafa(int a,int b)

{
return a+b;
}
public int suanjiafa(int a,int b,int c){
return a+b+c;
}

万物接对象，对象是（object）

 有和是

在做面向对象，使用对象功能时，要知道对象从何而不，如果是创建而来，就是“有”的意思，如果是自己有这个功能 ，那就是“是”的意思

单根继承

 一个类只能继承一个类，不能多继承

父类也叫超类，所以相关的关键字是super,父类也叫基类

构造函数顺序

创建子类对象前行要创建一个父类对象

if和if....else

最基本的条件语句是if

if（a>0）

{

System.exit(-1);

 }

if（a<0）

{

System.exit(2);

}else{

System.exit(1);

 }

switch

在用这种语句时，每个case下都要有一个break，在结尾必须要有一个default分支 语句。

char grade = 'D'

switch(grade){

case 'A';

System.out.println("Great job!");

break;

case 'B';

System.out.println("Great job!");

break;

default;

System.out.println("wqh");

如果两个case写在一起，说明这两个选择同一种分支。

for与foreach

for循环用于重复执行语句，直到条件得到满足

for(初始化；结束条件；迭代条件 ){

 }

fforeach循环是基于迭代器的

for(String zf : sz){

System.out.println(zf);

}

while和do循环

while循环

int i = 0;

int [] sz = {123,42,59,88};

while(sz[i]>99)

{

System.out.println(sz[i]);

i++;

}

do while循环

int i = 0;

int[] sz = {25,69,97,108};

do

{

System.out.println(sz[i]);

i++;

}

wile(i<5 && sz[i]> 68);

wile和 do wile的不同：wile的位置一个在循环体前，一个在循环体后，wile是先判断后执行，do wile是执行后判断

数组和集合的差别

数组在创建时，必须指定大小或者直接把所有数据都 放进去，而集合可以随便向里面加数据

String[] sz1 = {"a","b"};
for (String string : sz1) {
System.out.println(string);
}
int[] sz2 = new int[2];
for (int i : sz2) {
System.out.println(i);
}
boolean[] sz3 = new boolean[2];
for (boolean b : sz3) {
System.out.println(b);
}

System.out.println(c);
}

ArrayList,Vector,LinkedList

ArrayList jhl = new ArrayList();

jhl.add("111");

jhl.add("22");

jhl.add("333");

for(int i =  0;i<jhl.sete();i++){

System.out.println(jhl.get(i));

}

ArrayLis 和Vector是基于数组的集合，LinkedList是基于链表结构的集合

基于数组的查询快，基于链表结构的修改，删除，新增快

ArrayList和Vector的差别，线程是否安全的差别

map

map是基于键值对保存数据的（键 -- 值）

通过键可以找到对应的值

如果往里面加键相同的键值对，会把前面的覆盖

set和list的差别

sel是个无序的不可重复的集合

包

其实包就是一个存放class的文件夹，把功能类似的放在一起。

接口

接口不可以创建对象，只可以定义规则和标准，他的方法都是没有实现的（没有方法体）

public interface Dianqi{

public abstract void kai();

public abstract void guan();

}

public class Diannao implements Dianqi{

public void kai(){

Sytstem.out.println("按一下开机键")

}

public void kai(){

Sytstem.out.println("按一下开机键")

}

在编程时，让一个普通类的implements（实现）一个接口，需要实现它所有的方法。

为什么接口不能创建对象，就是要调就这个对象的方法，但是接口的立法都 是没有实现的，创建 这样的对象是没有意义的。如果真正的要创建这个类的对象，可以通过匿名类（抽象类）的方式，new接口对象，在这个接口下面我们马上把他的功能给实现了

普通类是实现了所有方法，接口是什么方法都没有实现的，一般方法末实现都认为方法加了一个abstract修饰，由于接口什么方法都没有实现，所以就去掉了这个关键字

实质上就是文件夹，用于存放class文件的，功能类似的放在一起。

普通类，抽象类，接口类

可以定义普通类继承于普通类，

可以定义普通类继承于抽象类

可以定义普通类实现与接口类。

抽象类可以继承抽象类

public class Mao extends Buru{

@Override
public void buru() {
System.out.println("mao buru");
}

   }

接口可以继承与接口

public interface Jiayongdianqi extends Dianqi{
public void yaokong();
}

抽象类也可以继承与接口 

子类在继承时，在继承普通类，就是获取父类的功能，继承抽象类就是获取了部分功能 ，把父类末实现的功能给实现，在实现接口类时，遵循接口所定义的标准，把接口所有的方法给实现了

重定

就是在调用方法时，调用父亲的对象时，父亲有这个方法，而自己也有这个方法，这就形成了重写

关于父类引用指向子类实体

Ren ren = new Student();

ren是父类的引用

new Stuent();是子类的实体

Dongwu dw;

Random r = new Random();
int i = r.nextInt(2);
if(i ==0)
{
dw = new Mao();
}else {
dw = new Dog();
}
dw.jiao();

}
}

ren对象只能调用Ren这个类方法，尽管我们知道ren这个引用真正指向的是一个Student对象。

强制转换

Dongwu dw;

//强制转换

Dog wangcai = (Dog)dw;
dw.jiao();

System.out.println(dw == wangcai);


Ren ren = new Student();

}
}