类与对象

一、ciass Person{

private int a=0;

private String b=null;

public static void main(String args){

Person per=null;

per=new Person();

}

}

Person per=null;开辟了一个Per的栈空间，a和b开辟了堆空间

per=new Peson()实例化per对象，指堆空间。

二、面对对象

封装性、继承性、多态性。多态为方法的重载

三 递归调用

从100+99：98+。。。1

import java.util.Scanner;public class Operation{public static void main(String args[]){System.out.println(addNum(100));}public static  int addNum(int num){if(num==1){return 1;}else{return num+addNum(num-1);}}}

四、为什么会有get，set方法

因为将类内的属性变为私有，进行封装。其他要要访问该属性就得在私有属性下面写get,set方法，其他类调用这些方法来访问该属性。

五、引用传递

import java.util.Scanner;class Ref{String temp="hello";}public class Operation{public static void main(String args[]){Ref r=new Ref();// r.temp="jike";tell(r);System.out.println(r.temp);}public static void tell(Ref r){r.temp="jike";}}

要想改变Ref里面的temp字符串，就必须为TEMP开辟一个堆空间r.temp;

import java.util.Scanner;class Ref{String temp="hello";}public class Operation{public static void main(String args[]){Ref r=new Ref(); tell(r.temp);System.out.println(r.temp);}public static void tell(String temp){temp="jike";}}

像上面这样写temp始终是hello;

六 继承

1.子类对象实例化，必须先调用父类的构造方法，之后调用子类的。

import java.util.Scanner;class Father{public Father(){System.out.println("父类构造方法");}}class Sun extends Father{public Sun(){System.out.println("子类构造方法");}}public class Operation{public static void main(String args[]){Sun fa=new Sun();}}

2.要调用父类的方法必须super();

import java.util.Scanner;class Father{public void tell(){System.out.println("父类方法");}}class Sun extends Father{public void tell(){System.out.println("重写父类方法");}}public class Operation{public static void main(String args[]){Sun fa=new Sun();fa.tell();}}

以上子类无法调用父类方法。

import java.util.Scanner;class Father{public void tell(){System.out.println("父类方法");}}class Sun extends Father{public void tell(){super.tell();System.out.println("重写父类方法");}}public class Operation{public static void main(String args[]){Sun fa=new Sun();fa.tell();}}

以上可以

3.子类重写的父类的方法不能有比父类更加严格的作用域,重写是方法名相同，参数也相同，返回值也相同，只是函数体不相同。重载是参数不同，函数体不同，只发生在；类里。重写发生在继承里面。

void print(){}是default。访问权限private<defaulr<public 

七 关键字

1.final关键字

1）使用final声明的类不能被继承，

2）声明的方法不能被重写，

3）声明的变量变为常量，

2 instanceof:判断一个对象到底是不是一个类的实例

import java.util.Scanner;class Father{public void tell1(){System.out.println("父类方法1");}public void tell2(){System.out.println("父类方法2");}}class Sun extends Father{public void tell1(){System.out.println("重写父类方法1");}public void tell3(){System.out.println("子类方法2");}}public class Operation{public static void main(String args[]){Father fa=new Father();System.out.println(fa instanceof Father);System.out.println(fa instanceof Sun);Father da=new Sun();System.out.println(da instanceof Father);System.out.println(da instanceof Sun);}}

八、接口

interface interfaceName{

全局变量

抽象方法

}

九、多态

1方法的重载和重写

2 对象的多态性，先向上在向下

  向上转型：程序自动完成

父类 父类对象=子类实例

向下转型：强制类型转换，子类和父类方法都可以调用

子类 子类对象=（子类） 父类实例

import java.util.Scanner;class Father{public void tell1(){System.out.println("父类方法1");}public void tell2(){System.out.println("父类方法2");}}class Sun extends Father{public void tell1(){System.out.println("重写父类方法1");}public void tell3(){System.out.println("子类方法2");}}public class Operation{public static void main(String args[]){// 向上转型Father fa=new Sun();fa.tell1();fa.tell2();// 向下转型/* Father fa=new Sun();Sun su=(Sun)fa;su.tell1();su.tell2();su.tell3(); */}}

多态性的应用

向上转型

import java.util.Scanner;class A{public void tell(){System.out.println("a----tell1");}}class B extends A{public void tell(){System.out.println("b---tell2");}}class C extends A{public void tell(){System.out.println("c---tell3");}}public class Operation{public static void main(String args[]){say(new B());}public static  void say(A a){a.tell();}}

接口的应用

import java.util.Scanner;interface USB{void start();void stop();}class C{public static void work(USB u){u.start();System.out.println("工作中");u.stop();}}class USBDisk implements USB{public void start(){System.out.println("U盘开始工作");}public void stop(){System.out.println("U盘停止工作");}} class Pointer implements USB{public void start(){System.out.println("打印机开始工作");}public void stop(){System.out.println("打印机停止工作");}}public class Operation{public static void main(String args[]){C.work(new USBDisk());C.work(new Pointer());}}

十、泛型

1、 以下是创建了两个泛型参数的类，大家可以运行了看看实例化泛型类的对象后，是否可以成功显示

class Gen<K,T>{private T take;private K key;public T getTake(){return take;}public void setTake(T take){this.take=take;}public K getKey(){return key;}public void setKey(K key){this.key=key;}}public class Operation{public static void main(String args[]){Gen<String,Integer> g=new Gen<String,Integer>();g.setKey("key");g.setTake(10);System.out.println(g.getKey()+""+g.getTake());}}

2、 如果我创建的是一个String的泛型，调用的函数参数又是Object类型，将String类型的对象赋值给OBJECT的对象就不出现转换异常。此时需要用通配符？

class Gen<T>{private T take;public T getTake(){return take;}public void setTake(T take){this.take=take;}public String toString(){return this.getTake().toString();}}public class Operation{public static void main(String args[]){Gen<String> g=new Gen<String>();g.setTake("jikexyueyuan");tell(g);}public static void tell(Gen<Object> i){System.out.println(i);}}

一下是修改后的

class Gen<T>{private T take;public T getTake(){return take;}public void setTake(T take){this.take=take;}public String toString(){return this.getTake().toString();}}public class Operation{public static void main(String args[]){Gen<String> g=new Gen<String>();g.setTake("jikexyueyuan");tell(g);}public static void tell(Gen<?> i){System.out.println(i);}}

泛型接口类

interface Mou<T>{public void say();}class Mons implements Mou<String>{private  String info;public Mons(String info){this.info=info;}public void setInfo(String s){info=s;}public String getInfo(){return info;}public void say(){}}public class Operation{public static void main(String args[]){Mons g=new Mons("jikexyueyuan");System.out.println(g.getInfo());}}

繁星函数

class Fun{public <T>T test(T t){return t;} }public class Operation{public static void main(String args[]){Fun f=new Fun();String s=f.test("zhanglu");System.out.println(s);}}

泛型数组

public class Operation{public static void main(String args[]){String arr[]={"www","jikexueyuan","com"};tell(arr);}public static <T>void tell(T arr[]){for(int i=0;i<arr.length;i++){System.out.println(arr[i]);}}}

十一、集合类(查看开发文档）

集合是一个动态数组，不同的是集合里面的对象内容可以恩义扩充,collection的常用子类有List set Queue,下面是list集合的使用，可以添加重复元素，排序方式是放入的顺序.

1 list集合

import java.util.ArrayList;import java.util.List;public class Operation{public static void main(String args[]){List<String> lists=null;// lists=new ArrayList<String>();//通过list的实现类实例化list接口类对象。Klists=new Vector<String>();lists.add("a");lists.add("b");lists.add("c");lists.remove(0);for(int i=0;i<lists.size();i++){System.out.println(lists.get(i));}System.out.println(lists);System.out.println("集合是否为空:"+lists.isEmpty());System.out.println("b是否存在："+lists.indexOf("b"));//返回具体数值的索引，返回整数}}

我们发现ArrayList与Vector实现结果是一样的，下面我们看看它们的使用区别

当要考虑线程安全的时候使用Vector,反之使用ArrayList

2 SET接口

ALT+CTRIL+上下箭头 表示窗口转动，ctrl+D表示复制当前行在他的右边

Set接口中不可以加入重复元素，但是可以排序，常用的接口子类

1）散列存放：HashSet

 2)有序存放：TreeSet

 import java.util.HashSet; import java.util.TreeSet;import java.util.Set;public class Operation{public static void main(String args[]){Set<String> Sets=null;// Sets=new HashSet<String>();Sets=new TreeSet<String>();Sets.add("a");Sets.add("b");Sets.add("c"); Sets.add("d");Sets.add("e");Sets.add("f"); System.out.println(Sets);System.out.println("集合是否为空:"+Sets.isEmpty());}} 

3 Iterator接口

只要是集合我们就要使用Iterator来进行输出。输入了多个对象，一个一个轮流判断，如果是对象就取走，判断下一个对象，不是退出。

4 ,Map 接口

MAP接口与集合有区别，map的保存时以键值对的形式保存，常用的子类有HashMap无序存放，Key不允许重复，Hashtable无序存放，KEY不允许重复.HASHMAP不是线程安全，hashTable是线程安全。HASHMAP允许value为空值，hashtable不允许为空值