当前位置:首页软件开发Java → java基础

java基础

时间:2020-12-10 00:36:28来源:互联网我要评论(0)

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(); //将字符串的内容全都转成大写

相关文章

网友评论

热门评论

最新评论

发表评论 查看所有评论()

昵称:
表情: 高兴 可 汗 我不要 害羞 好 下下下 送花 屎 亲亲
字数: 0/500 (您的评论需要经过审核才能显示)

关于万荚 | 联系方式 | 发展历程 | 版权声明 | 帮助(?) | 网站地图 | 友情链接

Copyright 2005-2020 16WJ.COM 〖万荚网〗 版权所有 桂ICP备18000060号 |

声明: 本站所有文章来自互联网 如有异议 请与本站联系