java基础

Java面向对象编程

一、基本成员

1.类

语法：修饰符 class 类名｛

//类成员

｝

类修饰符：public protected 缺省 private static abstract final

*final 和 abstract不能同时修饰一个类。

final表示不能被继承,abstract表示只能用于继承.

类成员：属性，方法，构造方法，类，接口，枚举类

成员分类：类相关(使用类名直接调用)

  对象相关(创建对象，才能通过对象调用)

2.封装

把类的状态信息隐藏在类内部，不允许外部程序直接调用，只能通过该类提供特定的方法来操作和访问

访问权限：private 类内部范围

  缺省   同包里的类访问

  protected 同包中的类访问,同项目中不同包中的了类访问.

  public 可以被同项目中所有类访问

实现：a:将内部状态信息(属性)用private修饰

  b:提供相关方法让外部调用

优点：安全性,完整性,复用率.

3.继承

语法：subclass extends superclass{

//类定义部分

}

*Java只支持单继承，每个类只能有一个直接父类

子类可以继承父类的哪些财产：

public 和 protected 修饰的属性和方法，是否同包都能继承

缺省修饰的属性和方法，但子类和父类必须同包

子类无法继承父类的财产：

private修饰的属性和方法.

父类的构造方法.

4.接口

语法：修饰符 interface 接口名｛

//成员

｝

彻底的抽象类。

@接口中的成员：属性(必须为常量)，方法(必须为抽象方法)，接口，类，枚举类

@非接口成员:构造方法，普通方法，普通属性，语句块.

@接口和抽象类都不能被实例化，只能用来被子类实现.

@接口中的实现类必须实现(重写)接口中所有方法.

*实现类的写法：

public class 类名 implements 接口1，接口2｛

//实现接口的方法

｝



接口思想：

作为程序外部交互的窗口，体现一种规范。

5.多态

同一个实现接口，使用不同的实例而执行不同的操作。

实现多态的条件：

1.继承的存在(继承是多态的基础，没有继承就没有多态)。

2.子类重写父类的方法(多态后调用子类重写后的方法)。

3.父类引用变量指向子类对象(子类到父类的类型转换)。

多态代码层面：

1.把父类作为方法的参数

public class Method(父类名 定义名){

定义名.方法名();

}

2.根据对象的引用来调用方法

public static main(String[] args){

//创建实例

Method zoa = new Method();

//传入需要调用的对象

zoa.方法名(new 对象());

}

instanceof

用于判断一个对象是否属于一个类或实现了一个接口。

重载与重写的区别

重载(Overloading) 方法名相同，参数类型不同，返回值类型可同可不同。

重写(Overriding) 子类重写父类的方法，相同的名称与参数。

二、类与类的关系

1.继承：类与类之间的关系，子类自动继承父类的成员。

优点：减少代码量 重用性 扩展性 维护性

2.实现：类与接口的关系

语法：类 Implements 接口1，接口2

优点：约束实现类具备某些行为，弥补Java单继承的不足，可以更好的实现多态。

3.依赖

指一个类的某个方法无法独立完成某个功能需要其它类协助完成。

体现依赖的形式：

Class A{

方法(B object){...}

}

//把类B作为类A方法的参数来调用。

依赖指程度较弱的依赖的关系，有偶然性。

例：人要过河，借助于桥或船。

4.关联

强依赖关系，长期性的依赖。

体现形式：将一个类作为另一个类的属性存在这个类中。

优势：得到一个类的对象就可以拿到另一个类的对象成员。

例：老师类 学生类

老师可以调用学生类对象的成员，学生类也可以调用老师类成员。

5.聚合

强依赖，关联的一种特例。

体现形式：整体和部分的关系，可以分离，有独立的生命周期。

例：公司 员工

Class 公司{

list<员工> 集合名 = new ArrayList<>(员工);

}

6.组合

强依赖，依赖程度比聚合更强。

体现形式：整体和部分的关系，不可以被分离，没有独立的生命周期，一个对象生命周期 结束，另一个也随这结束。

例：人 大脑

内聚

一个方法内部实现过程尽量独立，外界的改变，尽可能少地去影响这个方法。

耦合

一个类依赖于其它类的程度，依赖程度越高，耦合就越高。

三、设计原则

1.单一职责

每个类中只定义相关职责的方法。

2.里氏替代

在父类出现的地方都可以用子类进行无损替换。

3.开闭原则

对扩展开放，对修改关闭。

4.依赖倒置

面向接口编程，要求依赖抽象面不要依赖具体实现类。

5.接口隔离

将多个方法隔离在不同的接口中，不强迫实现类去实现其不需要的方法，只提供该类需要的方法。

四、集合框架

Collection 集合的顶集接口;存放的数据无序,可重复.

Collection<--List<--ArrayList，Likedlist，Vector(实现都是单个元素) --有序,允许重复.

Map<--HashMap,HashTable(实现类的元素为成对出现)

Collection<--Set<--HashSet(基于Map来实现)

常用类的区别

1．ArrayList: 效率高，多用于查询

2．Vector: 线程安全，多用于查询

存储数据方式同ArrayList一样,但它支持线程同步.

3．LinkedList:多用于插入和删除

存储本身数据外,还额外存储下个数据的存储地址.

4．HashMap: 元素可为空.

5．HashTable: 线程安全，元素不可为空.

6. HashSet: 存储数据无序,不允许重复.

从集合中提取数据的方法：

for循环 for(int i=0;i<集合名.size();i++){

//转换数据类型并输出

对象 对象名 = (对象)集合名.get(i);

system.out.println(对象名.数据或值);

}

遍历 for(对象 对象名:集合名){

system.out.prinln(对象名.数据或值);

}

迭代器 Iterator<对象名> 迭代名 = 集合名.Iterator();

while(迭代名.hasNext()){

对象名 自定义名 = 迭代名.next();

system.out.println(自定义名.get(值));

}

判断集合中是否存在的对象信息

if(集合名.contains(对象信息)){

system.out.println(判断值);

}

Map接口的用法

map<key,value> 集合名 = new HashMap<>(key,value);

//添加数据

集合名.put("key","数据");

获取键值的方法

key

for(key类型 key:集合名.key){

system.out.println(key);

}

value

for(值类型 value:集合名.value){

system.out.println(value);

}

key 和 value

for(key类型 key:集合名.keyset()){

//获得值与key

string value = 集合名.get(key);

system.out.println("key"+"value");

}

迭代器取数据

Iterator<数据类型> 迭代名 = 集合名.key和value.iterator();

while(迭代名.hasnext()){

数据类型 自定名= 迭代名.next();

system.out.println(自定名);

}



五、java语言来操作数据库(jdbc)

Class.forName("数据库驱动");//加载驱动

Concection con = DriverManager.getconnection("连接地址","用户名","密码");// 获得连接

statement stmt = con.createstatement(sql);//创建语句对象,处理sql语句

Resultset rs = stmt.excutequery(sql);//执行sql语句,并返回结果集

while(rs.next()){

String 字段名 = rs.getString("字段");//处理结果集

system.out.println("语句"+rs.getString("匹配字段名"));

}

rs.close();//按顺序关闭资源(结果集-语句对象-数据库连接)

stmt.close();

con.close();

语句对象安全用法

preparedStatement pstmt = con.preparedStatement(sql);

pstemt.excuteupdate();

pstemt.setstring(1,"参数");

String sql="增、删、改里面的字段都用 ？作为点位符";

六、LogciJava

1.java工作原理

.java-->字节码文件.class-->显示结果

Hello.java通过javac  Hello.java编译成Hello.class，通过java Hello显示运行后的结果

2.数据类型

  a.基本数据类型

  byte short int long float double char boolean

  b.引用数据类型

   数组 类 接口

3.变量:代表内存中所放的数据

int a = 5;

变量三要素：

数据类型 变量名=值

4.运算符：

  a.算术运算符   + - * /  %

  b.关系运算符  > 、>=、 <、 <=、 == 、!=

  c.逻辑运算符  && 、 ||  、 !

  d.赋值运算符  =

5.自动类型转换和强制类型转换

a.自动类型转换

int i = 10;

double d = i;

float f = 5.5F;

double d = f;

b.强制类型转换

double num = 5.2;

int i = (int)num;  

自动类型转换条件: a.目标类型大于源类型  b.数据类型要兼容

3、选择结构

a.单分支

b.双分支

c.多分支

  if(条件1){

代码块1

}...

else if(条件n){

代码块n

}else{

//以上条件均不成立，则运行此处代码

}

Switch语句

switch-case

switch(表达式){

case 常量1:

  代码块1

  break;

case 常量2:

  代码块2

  break;

...

case 常量n:

  代码块n

  break;

default:

代码块

}

值匹配成功就执行该case语句直到break语句为止,如果没有,则执行default后面的若干个语句。

在switch同一个语句中，case后的常量值必须互不相同。

4.循环结构

循环四要素：

a.循环变量的初始值

b.循环条件

c.循环操作

d.迭代部分

4.1.

for(循环变量的初始值;循环条件;迭代部分){

循环操作

}

4.2. 

while(循环条件){

   循环体(循环操作，迭代部分)

}



特点：先判断再执行

4.3. 

  do{

  循环体(循环操作，迭代部分)

}while(循环条件);

循点：先执行，再判断

5.输入与输出

Scanner input = new Scanner(System.in);

input.nextInt(); //获得整数

input.next();或input.nextLine();//获得字符串

input.nextDouble(); //获得小数

input.next().charAt(0); //获得char

....

输出：

System.out.println();或 System.out.print();

6.break和continue区别

a.使用场合不同

    break用于循环结构和switch-case结构

    continue用于循环结构

b.意义不同

    break用于循环结构表示终止循环或叫退出循环,用于switch-case结构表示跳出该结构

continue用于循环结构表示中止本次循环，继续进入下一轮循环

7.return表示结束方法

  a.用于方法中表示结束该方法，后续代码不执行

  b.用于方法中表示该方法的有返回值

8.数组

  特点：a.存储一组相同数据类型的数据

        b.内存空间连续

        c.长度固定



使用数组的步骤：

a.声明数组

   int[] a;

b.分配空间

    a = new int[5];

两步合为一步：int[] a = new int[5];

c.赋值

   a[0] = 2;

   a[1] = 2;

   a[2] = 2;

   a[3] = 2;



d.使用

例如：

int num = a[3]*10;

数组的赋值分为：

a.静态初始化 

String [] str ={"aa","bb","cc"};

String [] str =new String[]{"aa","bb","cc"};

b.动态初始化

int[] a = new int[5];

   a[0] = 2;

   a[1] = 2;

   a[2] = 2;

   a[3] = 2;



Arrays.sort(数组);//将指定数组进行升序排序

9.什么是对象

  局限的定义：客观存在的事物，可以看得见摸得着的东西

特点：属性和行为或功能

10.什么是类

   具有相同属性特征和行为的对象的集合

特点：属性和方法

11.对象与类的关系

   对象是具体的，类是抽象的

  关系： 对象抽象出类,类实例化出对象

12.如何定义类?

class 类名{

  属性1;

  属性2;

  ...

  属性n;



  public 返回值的类型   方法1(参数列表){}

  public 返回值的类型   方法2(参数列表){}

  ...

  public 返回值的类型   方法n(参数列表){}



}

13.如何使用对象?

a.创建类的对象

    类  对象名 =  new 类();

b.调用对象的属性和方法

   对象名 .属性

  对象名 .方法

注意：属性是每个对象所独有，方法是同一个类的所有对象共用的



  Person p1 = new Person();

  p1.name = "zhangsan";

  p1.age = 20;

  p1.show();

  Person p2 = new Person();

  p2.name = "lisi";

  p2.age = 18;

  p2.show();

14.如何定义方法？

  语法：

访问修饰符  返回值的类型   方法名(参数列表){

  方法体

}

例如：

public int add(int num1,int num2){

  return num1+num2;

}

15.方法什么时候要带参？

   当要完成该方法的功能时，需要外部给它数据时，就需要带参



16.方法什么时候要返回值？

当我们很关心该方法执行后的结果的时候，该方法需要设计返回值



17.String常用方法:

  length(); //获得字符串的长度

  trim();//去掉字符串前后空格

  indexOf(String ch);//在源始字符串中查找ch这个字符串第一次出现的位置，找到返回其位置,找不到返回-1

  lastIndexOf(String ch)////在源始字符串中查找ch这个字符串最后一次出现的位置，找到返回其位置,找不到返回-1

  subString(int index)//从index处开始往后取所有的字符

  subString(int index1,int index2) //取[index1,index2)之间的字符串

  split(String s) //按照指定分隔符分割字符串，返回一个String[]

  equals(String s); //比较两个字符串的内容是否相同

  equalsIgnorecase(); //忽略大小写比较两个字符串的内容是否相同

  toLowerCase(); //将字符串的内容全都转成小写

  toUpperCase(); //将字符串的内容全都转成大写