5. 第五阶段 测试开发技术 - JAVA
5. 第五阶段 测试开发技术 - JAVA
第一章 初识JAVA
-
java简介
-
java语言的特性
-
搭建java环境
-
第一个java程序
public class Helloworld{ public static void main(String[] args){ System.out.println("Hello world"); //println自带换行 System.out.print("Hello"); System.out.print("world"); } } -
一个源文件中最多只能有一个public类,其他类的个数不限,若源文件包含一个public类,那文件名必须按该类名命名
-
Java方法由一条条语句构成，每个语句以“;”结束。
-
注释
- 单行注释
//- 多行注释
/*注释内容*/
- 多行注释
- 单行注释
-
JAVA命名规则
- 类名 :每个单词的首字母大写
- 方法名 : 第一个单词小写,后面每个单词首字母大写
第二章 表达式和数据类型
java主类结构
-
每一个应用程序都必须包含一个main()方法
-
含有main()方法的类称为主类
-
一个java程序是由若干个类组成的,
-
包名的命名规则
-
包名中的字母一律小写
-
不能有数字
-
公司的域名的倒写 + 项目名 + 模块名
www.mi.com com.mi.test.testadd
-
-
声明成员(全局)变量和局部变量
- 通常类的属性称为类的全局变量(成员变量)
- 方法中的属性称为局部变量
- 全局变量声明在类体中
- 局部变量声明在方法体中
-
变量的声明 :
数据类型 变量名或数据类型 变量名=值
基础数据类型
-
String类型
- 表示字符串,相对于cahr而言,可以储存多个字符,需要使用双引号
-
数据类型转换
-
自动类型转换 (隐式转换)
-
满足的条件 : 小类型转大类型,小范围转大范围
-
基本数据数据类型自动转换规律
byte - short - int - long - float - double char - int - long - float - double char在一定条件下可以和byte类型相互转换public class test { public static void main(String[] args) { // 小类型转大类型 // byte转int byte a=2; int b; b=a; System.out.println(b); } }
-
-
强制类型转换 (显式转换)
数据类型1 变量的名字 = (数据类型1) 变量的名字 double d=3.14d; int i (int)d; Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。 -
转义字符
\` 单引号字符 \\ 反斜杠字符 \t 垂直制表符,将光标移到下一个制表符的位置 \r 回车 \n 换行
-
-
Math类
Math是lang包下的类,里面定义了很多方法来实现常用的数学运算 Math类中的方法都是静态的 Math类中的方法 abs() : 求绝对值 sqrt() : 求平方根 pow() : 求乘方 random() : 获得0-1之间的随机数 public class test { public static void main(String[] args) { System.out.println("求绝对值" + Math.abs(-10)); System.out.println("求平方根" + Math.sqrt(9)); System.out.println("求2的3次方" + Math.pow(2,3)); System.out.println("获得0-100之间的随机数" + Math.random()*100); } }
变量与常量
-
声明常量
- 常量在整个程序中只能被赋值一次
- 声明常量格式
final 数据类型=常量名称=值例如final double PI=3.1415926D - 常量名通常使用大写字母
- 当定义final变量术语全局变量时,必须在定义时就设定它的初值,否则编译错误
-
算数运算符
运算符 运算 范例 结果 + 正号 +2 2 - 负号 a=3,-a -3 + 加 2+2 4 - 减 5-3 2 * 乘 / 除 % 取余 ++ 自增(前) a=2;b=++a a=3;b=3 ++ 自增(后) a=2;b=a++ a=3;b=2 – 自减(前) a=2;b=–a a=1;b=1 – 自减(后) a=2;b=a– a=1;b=2 + 字符串相加 -
逻辑运算符
运算符 运算 范例 结果 运算解释 & 与 都为真才真 && 与 都为真才真 | 或 有一真就真 || 或 有一真就真 ^ xor异或 false^true true 双方不同则为真 ! not非 !true false 取反 - “&” 和 “&&” 的区别
- &：左边无论真假,右边都进行运算
- && : 如果左边为假,右边不进行运算
- “|” 和 “||” 的区别
- “|” : 左边无论真假,右边都进行运算
- “||” : 如果左边为真,右边不参与运算
- 逻辑运算符用于连接布尔型表达式,在java中不可这样 :
3 - 应该这样写 :
x>3 & x<6
- “&” 和 “&&” 的区别
表达式
- 三目运算符
- 格式 :
布尔表达式1?表达式2:表达式3;示例 :System.out.println((4<5)?"a":"b");
- 格式 :
第三章 语句结构和数组
java中代码的格式
语句结构
-
if-else-if
-
格式
if(条件1){ 条件1成立执行的代码块 }else if(条件2){ 条件2成立执行的代码块 }else if(条件3){ 条件3成立执行的代码块 }else{ 以上条件都不成立执行的代码块 }
-
-
Scanner类
import java.util.Scanner; public class test { public static void main(String[] args) { // 根据输入的分数评价优良差 System.out.println("请输入分数:"); // 根据Scanner类生成对应的对象,先导入Scanner类包 Scanner sc = new Scanner(System.in); // 根据对象调用命令行中输入的方法 int i = sc.nextInt(); if(i<60 && i>=0) { System.out.println("这次没考好哦,要努力喽!"); }else if(i>=60 && i<80) { System.out.println("及格了,再接再厉"); }else if(i>=80 && i<90) { System.out.println("你狠优秀!"); }else if(i>=90 && i<=100) { System.out.println("太棒了你"); }else { System.out.println("输入错误!"); } } } -
switch多分支语句
-
格式
switch(变量){ case 常量1: 语句1; break; case 常量2: 语句2; break; … … case 常量N: 语句N; break; default: 语句; break; } public class test { public static void main(String args[]) { int i = 1; switch (i) { case 0: System.out.println("zero"); break; case 1: System.out.println("one"); break; default: System.out.println("default"); break; } } }- switch****语句有关规则
switch(表达式)中表达式的返回值必须是下述几种类型之一： byte，short，char，int，String, 枚举； case子句中的值必须是常量，且所有case子句中的值应是不同的； default子句是可任选的，当没有匹配的case时，执行default break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
-
-
循环语句
-
while
public class test{ public static void main(String[] args) { // 输出1-100数字 int i=1; while(i<=100) { System.out.println(i); i++; } } }break 循环一旦遇到break,跳出循环 continue 跳转到循环开始的地方public class test { public static void main(String[] args) { // 求1-100之间的偶数和 int i = 1, sum = 0; while (i <= 100) { if (i % 2 == 0) { sum = sum + i; } i++; } ; System.out.println(sum); } } -
do … while
-
格式
do｛ 语句或语句块; ｝while(布尔值测试表达式);public class test { public static void main(String[] args) { int i=1,sum=0; do { sum += i; i++; }while(i<=10); System.out.println(sum); } }- 先循环后判断
- 至少执行一次循环体
-
-
for
-
格式
for(初始值;条件;运算法则){ 循环体; } public class test { public static void main(String[] args) { // 循环输出打印1-10 for(int i=1;i<=10;i++) { System.out.println(i); } } }public class test { public static void main(String[] args) { for(int i=1;i<=6;i++) { for(int j=i;j<=6;j++) { System.out.print("*"); } System.out.println(); } } } ****** ***** **** *** ** *public class test { public static void main(String[] args) { // 九九乘法表 for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(j + "x" + i + "=" + j * i + "\t"); } System.out.println(); } } }
-
-
数组
-
数组的概述
- 数组是具有相同数据类型的一组数据的集合
- 在java中,可将数组看做是一个对象
-
一位数组的创建和使用
-
一位数组两种声明格式 :
数组元素类型 数组名字[]、数组元素类型[] 数组名字 -
public class array { public static void main(String[] args) { // 声明一个整型的数组 int arr[]; // 字符串的数组 String str[]; } } -
声明数组后还不能立即给任何元素,需要给数组分配空间
-
-
给数组分配空间
-
格式 :
数组名字 = new 数组元素类型[数组元素的个数] -
public class array { public static void main(String[] args) { // 声明一个整型的数组 int arr[]; // 字符串的数组 String str[]; // 给数组分配空间 arr = new int[6]; str = new String[4]; } } -
使用ew关键字为数组分配内存时,整型数组中各个元素的初始值都是0
-
声明的同事为数组分配内存空间
-
语法结构 :
数组元素类型[] 数组名=new 数组元素类型[元素个数]、
数组元素类型 数组名[] = new 数组元素类型[元素个数]int month[] = new int(12) -
给数组中的元素赋值
-
public class array { public static void main(String[] args) { // 声明一个整型的数组 int arr[]; // 字符串的数组 String str[]; // 给数组分配空间 arr = new int[6]; str = new String[4]; // 给数组中的元素赋值 System.out.println(arr[0]); // 0 arr[0]=666; System.out.println(arr[0]); // 666 } }
-
-
初始化一维数组
- 两种格式 :
int arr[] = new int[]{1,3,5,9,7}、int arr2[]={10,2,55,66}
- 两种格式 :
-
-
二维数组的创建和使用
-
二维数组常用于表示表,表中的信息以行和列的形式组织
-
二维数组的创建
-
先声明,然后用new运算符进行内存分配
数组元素类型 数组名[][] 数据类型[][] 数组名 =new 数据类型[m][n] //m:储存了m个数组; n:二维数组中储存的每个数组的大小 int[][] arrs= new int[2][3]; 2指arrs存储了2个一维数组 3指arrs中这两个数组,每组大小都是3 -
二维数组数据
int[][] arrs = {{1,2,3},{4,5},{6}}; -
二维数组定义方式扩展
数据类型[][] 数组名 =new 数据类型[m][] int[][] arrs = new int[3][]
-
-
-
数组的基本操作
-
length 获取长度
public class array { public static void main(String[] args) { // 声明一个数组 int arr[]= {1,2,4,9,6}; // 打印数组的长度 System.out.println(arr.length); // 5 } }
-
-
数组排序算法
-
对数组排序
使用Arrays类的静态方法sort()对数据进行升序排序 :
Arrays.sirt(object)object是指要排序数组名import java.util.Arrays; public class array { public static void main(String[] args) { // 声明一个数组 int arr[]= {1,80,4,9,6}; // 对数组进行排序 Arrays.sort(arr); // 对数组进行遍历 for(int i=0;i<arr.length;i++) { System.out.println(arr[i]); } } } /* 结果 1 4 6 9 80*/
-
-
复制数组
-
使用Arrays类的copyOf()方法与copyOfRange()方法实现对数组的复制
-
copyOf()方法 :
-
copyOf(arr,newlength)arr: 目标数组, newlength:int型常量,指复制后新数组的长度 -
说明 : 新数组长度>旧时,元素不够用0来凑; 新<旧,截取
import java.util.Arrays; public class array { public static void main(String[] args) { // 声明一个数组 int arr[]= {1,80,4,9,6}; // 复制数组 int arr1[]=Arrays.copyOf(arr, 2); // 对数组进行遍历 for(int i=0;i<arr1.length;i++) { System.out.println(arr1[i]); } } } /* 1 80 */
-
-
copyOfRange() 方法
-
语法 :
copyOfRange(arr,formIndex,toIndex)-
arr 目标数组; formIndex:复制数组内元素的起始索引; toIndex: 结束索引(不包含)
import java.util.Arrays; public class array { public static void main(String[] args) { // 声明一个数组 int arr[]= {1,80,4,9,6}; // 复制数组 int arr1[]=Arrays.copyOfRange(arr,1,2); // 对数组进行遍历 for(int i=0;i<arr1.length;i++) { System.out.println(arr1[i]); } } } // 结果 : 80
-
-
-
-
排序算法
-
冒泡
public class maopao { public static void main(String[] args) { // 冒泡排序 int arr[] = {12,55,3,22,1,6}; // 外层循环 控制轮次 for(int i=1;i<arr.length;i++) { // 内层循环, 遍历数组元素,进行对比换位 for(int j=0;j<arr.length-i;j++) { // 相邻两个数对比,大的放右边 if(arr[j]>arr[j+1]) { int temp = arr[j]; //设置中间值 arr[j]=arr[j+1]; arr[j+1]=temp; } } } // 遍历打印查看排序结果 for(int i=0;i<arr.length;i++) { System.out.println(arr[i]); } } } -
遍历数组方式二
public class bianli { public static void main(String[] args) { // 遍历数组方式二 int arr[] = {12,55,3,22,1,6}; for(int i:arr) { //i是一个变量,用来接收数组中的每一个元素 System.out.println(i); } } }
第四章 面向对象
面向对象概述
类
-
声明类的语法格式
修饰符 class 类名{ 属性声明; 方法声明; } 说明 : 修饰符 public: 类可以被任意访问 举例 public class Person{ private int age; //声明私有变量变量age public void showAge(int i){ //声明方法showAge() age = i; } } -
类的属性
语法格式 修饰符 类型 属性名=初值; 说明 : 修饰符private:该声明的属性只能由该类的方法访问 修饰符public: 该声明的属性可以被类以外的方法访问 举例 public class Person{ private int age; // 声明private变量age public String name="lili" // 声明public变量name } -
类的方法
语法格式 : 修饰符 返回值类型 方法名(参数列表){ 方法体语句; } 说明 : 修饰符 : public,private,protected等 返回值类型 : return语句传递返回值. 没有返回值则返回值类型用void 举例 : public class Person{ private int age; public int getAge(){ //声明方法getAge return age; } public void setAge(int i){ //声明放大setAge age = i; // 将参数i的值赋给类的成员变量age } } -
在java文件中,public修饰的类,只能出现一次
-
自定义类
// 声明自定义Animal、Car两个类 package com.animal; // 声明一个自定义类Animal public class Animal { // 属性 名字 颜色 体重 public String name; public String color; public int weight; // 方法 public void eat() { System.out.println("正在吃!"); } public void study() { System.out.println("正在学习!"); } } // 声明一个车类 class Car{ // 属性 价格 int price; // 方法 public void run() { System.out.println("跑!!!"); } } // 由于没有程序主入口,因此这两个类无法运行,运行需要先实例化- 实例化类对象
// 用自定义的类生成对象 package com.animal; public class test { public static void main(String[] args) { // 用new生成类对象.大象 // 格式 : 类名 对象名=new 类名(); Animal elephant = new Animal(); // 调用属性 elephant.name = "盼盼"; elephant.color = "黑白"; elephant.weight = 100; // 调用方法 elephant.eat(); elephant.study(); System.out.println("名字 :" + elephant.name); // 实例化车对象 Car car=new Car(); car.price = 999; car.run(); } } -
权限修饰符
public 对外公开 所有类都可以访问 protected 受保护的 子类及其同一个包中的类可以访问 默认的 没有访问修饰符 只向同一个包中的类公开 private 私有的 只有类本身可以访问,不对外公开 abstract :可以用来修饰类和成员方法,用该修饰符修饰的类表示抽象类,用该修饰符修饰的方法表示抽象方法 -
面向对象三大特性
-
封装
- 封装是面向对象编程的核心思想
- 封装的思想 : 将对象的属性和行为封住起来,其载体就是类,类通常对客户隐藏其实际细节
- 封装的好处 : 保证类内部数据的完整性,提高程序的可维护性
public class fz { public static void main(String[] args) { // 对Animal实例化对象 Animal a1 = new Animal(); // a1.name = "团团"; 因为是被封装起来的,因此无法被调用 // 可调用的public声明的一个方法 a1.play(); // 结果 : 正在玩 // setter和getter方法提供了私有化成员的对外操作 } } // 封装 - 动物类 class Animal{ // 对属性进行封装 - private private String name; private int age; // 对方法部分封装 private void eat() { System.out.println("正在吃"); } public void play() { System.out.println("正在玩"); } } -
setter和getter方法
setter方法格式 : public void set属性名(数据类型 属性名){ this.属性名 = 属性名; } getter方法格式 : public void get属性名(){ return 属性名; }public class fz { public static void main(String[] args) { // 对Animal实例化对象 Animal a1 = new Animal(); // setter和getter方法提供了私有化成员的对外操作 // 通过set设置name a1.setName("国宝"); // 实参 // 通过get获取name a1.getName(); System.out.println(a1.getName()); //调用方法 a1.getEat(); } } // 封装 - 动物类 class Animal{ // 对属性进行封装 - private private String name; private int age; // setter和getter方法提供了私有化成员的对外操作 // 设置set方法 public void setName(String name) { this.name = name; } // 获取getter方法 public String getName() { return this.name; } // 对方法部分封装 private void eat() { System.out.println("正在吃"); } public void play() { System.out.println("正在玩"); } // 获取eat的方法 public void getEat() { //自定义方法的调用 eat() eat(); } } -
继承
- 继承的好处 : 缩短软件开发的时间,减少系统在使用过程中出现错误的几率
-
多态
-
-
成员变量和局部变量
定义位置 : 成员变量 : 在方法之外,类之内 局部变量 : 在方法内部 使用范围 : 成员变量 : 在整个类中都可以访问 局部变量 : 只能在局部变量所在的方法内部访问public class TestBl { public static void main(String[] args) { // 实例化对象Bl Bl bl=new Bl(); bl.show1(); bl.show2(); } } // 声明一个类 class Bl{ // 声明一个全局变量 int a = 6; // 声明一个方法 public void show1() { // 声明局部变量 int b = 7; System.out.println(a); System.out.println(b); } // 声明另一方法 public void show2() { System.out.println(a); // System.out.println(b); b是局部变量,在其他方法中无法访问 } }
this关键字
-
使用this关键字将数值赋予类中的成员变量
public void setName(String name){ this.name=name; } 说明 : this.name 是指这个类中的name成员变量
类的构造方法
-
是一个与类同名的方法,对象的创建就是通过构造方法完成的
-
每当类要实例化一个对象时,类都会自动调用构造方法
-
格式
访问修饰符 类名(){ } 其中: public 是构造方法修饰符 特点 : 1.构造方法没有返回值 2.构造方法的名称要与本类的名称相同 构造方法的作用 :一般用来对属性进行赋值 (初始化)public class TestBl { public static void main(String[] args) { // 实例化Person Person p1 = new Person(); // 调用无参构造方法 p1.study(); p1.setName("*--张三--*"); System.out.println(p1.getName()); // 上面两行代码结果 : 无参构造方法 学习 *--张三--* Person p2 = new Person("p2"); // 有参构造方法:p2 } } // 自定义一个类 class Person{ String name; // 无参的构造方法 public Person() { System.out.println("无参构造方法"); } // 有参构造方法 public Person(String name) { this.name = name; System.out.println("有参构造方法:" + this.name); } //setter public void setName(String name) { this.name = name; } //获取name public String getName() { return this.name; } // 自定义方法 public void study() { System.out.println("学习"); } }package com.test.student; public class testStudent { public static void main(String[] args) { // 用无参构造方法生成对象 Student s1 = new Student(); s1.setName("张三"); s1.setAge(22); System.out.println("姓名:"+s1.getName() + " 年龄:" + s1.getAge()); // 用有参构造方法生成对象 Student s2 = new Student("李四",18); System.out.println("姓名:"+s2.getName() + " 年龄:" + s2.getAge()); } } /* 创建一个学生类 学生有名字、年龄属性 有吃饭、学习方法 创建两个学生对象 分别通过setter和构造方法时效件属性初始化 最后输出学生的姓名、年龄 */ class Student { // 姓名 年齡 private String name; private int age; // 无参的构造方法 public Student() { } // 有参构造方法,属性初始化 public Student(String name,int age) { this.name = name; this.age = age; } // 通过setter方法进行赋值 public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } // getter方法获取姓名和年龄 public String getName() { return this.name; } public int getAge() { return this.age; } // 自定义方法 public void eat() { System.out.println("天天吃"); } public void study() { System.out.println("努力学习"); } }有参无参setter等构造声明顺序 class 类名 { 属性 无参构造方法 有参构造方法 setter和getter 自定义方法 } -
构造方法和普通方法的区别
方法名 : 构造方法 : 构造方法名必须和类名保持一致 普通方法 : 见名知意 返回值 : 构造方法 : 没有返回值.也没有void 普通方法 : 正常的返回值 方法调用 : 构造方法 : 自己不能调用,只能自在创建对象时,由java虚拟机来调用 普通方法 : 方法名(参数列表) 方法体 : 构造方法 : 可以写任意,但一般用来给属性赋值(初始化) 普通方法 : 任意代码都可以 构造方法 : 如果一个都不写,系统会给我们添加一个默认,如果写了,不管是什么构造方法,系统不再添默认的构造方法
继承
-
子类继承父类的特征和行为,使得子类具有父类的各种属性和方法
-
java通过extends关键词实现类与类的继承
class 子类名 extends 父类名{}
-
继承的特点
java一个类只能有一个父类,不可以有多个父类 java支持多层继承(继承体系) class A{} class B extends A{} class C extends B{} -
继承的一些说明
1.子类继承父类的所有成员,但父类的私有成员,因权限(private)不能被访问 (通过setter getter访问) 2.构造方法不能被继承,但子类可通过super()关键字访问父类构造方法 -
继承原则
1.java不允许选择继承,不能为了部分功能而继承 2.继承中类之间体现的是 : "is a" 的关系 (一个子类只能继承一个父类)public class testAnimal { public static void main(String[] args) { // 通过无参构造方法实例化对象 // // 实例化Cat // Cat cat = new Cat(); // cat.setName("小花"); // String name = cat.getName(); // System.out.println(name); // cat.eat(); // cat.say(); // // 上边运行结果 // /* 父类的无参构造方法! // * 小花 // * 吃鱼 // * 喵喵喵 // * */ // 通过有参方法实例化对象 Cat cat = new Cat("喵喵", "黄色"); System.out.println(cat.getName()); cat.eat(); cat.say(); /* * 结果 父类有参构造方法 喵喵 吃鱼 喵喵喵 */ } } // 声明一个父类Animal class Animal { // 属性 name,color private String name; private String color; // 声明无参构造方法 public Animal() { System.out.println("父类的无参构造方法!"); } // 声明有参构造方法 public Animal(String name, String color) { this.name = name; this.color = color; System.out.println("父类有参构造方法"); } // setter getter public void setName(String name) { this.name = name; } public String getName() { return this.name; } // 方法 eat say public void eat() { } public void say() { } } // 声明子类 class Cat extends Animal { // 在子类声明一个无参构造方法去继承父类的无参构造方法 public Cat() { // super() 是出现在子类的构造方法里面的 super(); } // 声明有参构造方法 public Cat(String name, String color) { super(name, color); // 直接调用父类的有参构造方法 } // 父类方法的重写 public void eat() { System.out.println("吃鱼"); } public void say() { System.out.println("喵喵喵"); } } class dog extends Animal { // 方法重写 public void eat() { System.out.println("吃骨头"); } public void say() { System.out.println("汪汪汪"); } } -
继承中的成员
java支持子类定义相同的成员 成员变量、成员方法可以和父类相同 但当使用对象的成员时,要使用就近原则 1.先找子类成员 2.子类没有找父类成员 3.都没有报错 当子类和父类成员相同却想用父类成员时,需要用supr关键字标明 -
super关键字
super只能在子类的方式使用,且对当前对象的父类的引用 super(...)调用父类构造方式时,只能在子类的构造函数中使用,且必须是子类构造函数的第一行 this()和super()不能同时出现
多态
-
多态的条件
1.有继承关系 2.有方法重写(多态的意义) 3.父类引用指向子类对象(多态的核心)举例
Cat cat = new Cat() Animal cat = new Cat(); Animal 是父类 Cat是子类 Animal cat = new Cat(); 父类的引用指向子类的对象
抽象abstract
-
抽象类
-
格式 :
abstract class 类名{} -
特点 :
- 1.不能实例化 (还有构造方法)
- 继承抽象类的子类必须重写抽象类中的所有抽象方法,除非子类也是抽象类
-
抽象方法
-
在普通方法的访问修饰符上增加abstract
-
特点 :
- 抽象方法不能有方法体
- 抽象方法必须在抽象类中
- 子类必须重写所有的抽象方法,除非子类也是抽象的
-
抽象类中的成员特点
- 成员变量 : 成员变量、常量都可以有
- 成员方法 : 可以有成员方法,也可以有抽象方法
- 构造方法 : 有构造方法,但不能实例化
public class chouXiang { public static void main(String[] args) { // 尝试实例化抽象类A // A a = new A(); // 报错 } } // 抽象类A abstract class A { // 抽象方法 public abstract void show(); // 不能有方法体 } // 声明一个子类 class ZiLei extends A { @Override // 继承抽象类的子类必须重写所有抽象方法 public void show() { // TODO Auto-generated method stub } } // 抽象类C 继承抽象类A 不用重写抽象方法 abstract class C extends A { }package com.test.Animal; public class testAnimal { public static void main(String[] args) { // TODO Auto-generated method stub } } // 抽象类 abstract class Animal { public abstract void eat(); public abstract void say(); } class Cat extends Animal { // 等子类继承抽象类父类的时候,如子类不是抽象类,则强制子类重写父类所有的抽象方法 @Override public void eat() { System.out.println("吃鱼"); } @Override public void say() { System.out.println("喵喵喵"); } }
-
-
-
接口
-
接口
-
是一种比抽象类更加抽象的"类结构"
-
定义的格式 :
interface 接口名{} -
使用格式 :
class 子类 implements 接口名 {}表示子类实现了这个接口 -
注意
- 接口可以多实现
- 实现接口就必须重写接口中的所有抽象方法
- 接口中的方法默认访问修饰符是
- 接口中的常量默认访问修饰符是 “public static final”
- 接口只能出现两种方法: 抽象方法和静态常量
package com.ts.testinterface; public class Testinterface { public static void main(String[] args) { // TODO Auto-generated method stub } } // 声明一个接口类A interface A { // 抽象常量 public static final int NUM = 5; int I = 6; // 不写默认public static final // 抽象方法 public abstract void show(); void test(); // 不写修饰符默认 "public abstract" } // 声明接口B interface B { void study(); } /* * 当一个类既有继承,又有实现接口,要先继承,后实现接口 class 子类 extends 父类 implements 接口{} */ // 声明一个类 C 实现接口A class C implements A, B { // 必须重写接口的所有抽象方法 @Override public void show() { // TODO Auto-generated method stub } @Override public void test() { // TODO Auto-generated method stub } @Override public void study() { // TODO Auto-generated method stub } } -
接口案例
package com.ts.testanimal; public class TestAnimal { public static void main(String[] args) { // 实例化Cat Cat cat = new Cat(); cat.name = "小花"; cat.eat(); cat.jump(); cat.sleep(); System.out.println(cat.name); } } /* * 猫狗案例 猫和狗都有自己的名字 可以吃和睡 eat(),sleep() 可以跳jump(),用接口实现 */ // 跳接口 interface Jump { void jump(); } // 抽象父类Animal abstract class Animal { // 声明属性name String name; // 抽象方法eat() public abstract void eat(); // 抽象方法sleep() public abstract void sleep(); } // 声明子类猫继承父类animal并实现接口Jump class Cat extends Animal implements Jump { @Override public void jump() { System.out.println("I can jump"); } @Override public void eat() { System.out.println("I like eat fish"); } @Override public void sleep() { System.out.println("呼呼呼"); } } // 声明子类狗继承父类animal并实现接口Jump class Dog extends Animal implements Jump { @Override public void jump() { System.out.println("I can Jump,but not height"); } @Override public void eat() { System.out.println("I like eat bone"); } @Override public void sleep() { System.out.println("呼噜噜"); } }
-
-
抽象类和接口的区别
成员变量 : 抽象类 : 可以有变量,可以有常量 接口 : 只能有常量 成员方法 : 抽象类 : 可以有成员方法,可以有抽象方法 接口 : 只能有抽象方法 构造方法 : 抽象类 : 有构造函数,但不能创建对象 接口 : 没有构造函数 设计原则 : 抽象类 : 抽象类和类之间是继承关系,强调继承 接口 : 接口和类之间实现关系,强调拥有或包含
第五章 static和String
Static关键字
-
可以修饰属性和方法
- 修饰成员时,则类的所有对象都共享该成员;可以用使用
类名.成员进行访问 - 静态方法不能调用非静态成员,也不能使用this
- 局部变量不能是静态的
- 修饰成员时,则类的所有对象都共享该成员;可以用使用
-
public class TestS { public static void main(String[] args) { // 实例化TestStatic TestStatic t1 = new TestStatic(); System.out.println(t1.num); // 666 System.out.println(TestStatic.num); // 666 System.out.println(t1.str); // 非静态属性 t1.show(); // 打印静态方法 TestStatic.show(); // 打印静态方法 t1.test(); // 非静态属性 } } class TestStatic { // 声明一个静态的属性 static int num = 666; // 声明一个非静态的属性 String str = "非静态属性"; String name; public void setName(String name) { this.name = name; } // public static void setName1(String name) { // this.name = name; // 静态方法中不能使用this // } // 声明一个非静态的方法 public void test() { // 声明一个局部变量 // static int i=4; // static不能修饰修饰局部变量 System.out.println("非静态方法"); System.out.println(str); // 非静态方法调用非静态属性 System.out.println(num); // 非静态方法调用静态属性 show(); // 非静态的方法可以调用静态的方法 } // 声明一个静态的方法 public static void show() { System.out.println("打印静态方法"); System.out.println(num); // System.out.println(str); // 静态方法无法调用非静态属性 // test(); // 静态方法不能调用非静态的所有成员 } } -
代码块
代码块 : 局部代码块 : 方法中,限制变量的使用范围 狗仔代码块 : 类中、方法之外,执行任何构造方法之前,都必须先执行构造代码块 静态代码块 : 类中、方法之外,只在类加载的时候执行一次,而且仅仅一次 -
static的优缺点:
- 优点 :
- 修饰属性时,类的所有对象公用这一个属性,节省内存空间
- 访问方便,不需要再创建对象,直接
类.属性
- 缺点 :
- 生命周期太长,涉及到内存溢出问题
- 访问有限制
- 优点 :
-
static在使用时的注意事项
- 静态方法不能使用非静态变量
- 非静态方法可以访问静态变量
- 静态方法中不能使用this
- 局部变量是不允许是静态的
String类
-
String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象
-
java把String类声明为final类,不能被继承
-
String类对象创建后不能修改,由0或多个字符组成,包含在一对双引号之间
-
String类对象的创建
-
字符串声明 :
String stringName; -
字符串创建 :
String stringName = new String(字符串常量)或stringName = 字符串常量public class TestString { public static void main(String[] args) { // 声明String对象 String str1 = "你好"; // new对象 String str2 = new String("Hello"); System.out.println(str2); // Hello } } -
获取字符串长度
- 语法 :
str.length();- 包括字符串对象里面的空格
- 语法 :
-
字符串通过
toCharArray()转换为字符数组String str = "1234数字"; char[] c = str.toCharArray(); for(int i=0;i<c.length;i++){ System.out.println(c[i]); } -
indexOf(String s) - **返回字符串s在指定字符串首次出现的索引位置,若找不到返回-1
-
语法 :
str.indexOF(substr)-
str 是任意字符; substr是要搜索的字符串
String str="we are family"; int index1=str.indexOf("a"); // 查找str中a的索引
-
-
-
lastIndexOf(String str)
- 当调用字符串的lastIndexOf()方法时,会从当前字符串的开始位置检索字符串str,并将最后一次出现str的索引位置返回,没有查到返回-1
- 如果lastIndexOf()方法中参数时空字符串""(没有空格),则返回的结果与调用该字符串length()方法结果相同
-
charAt(int index) 获取指定索引位置的字符
-
语法 :
str.charAt(int index)-
str: 任意字符串
-
index : 整数型,用于指定要返回字符的索引下标
String str = "hello world"; char str2 = str.charAt(4);
-
-
-
substring() - 截取字符串
-
语法 :
str.substring(int beginIndex)利用字符串下标从指定的索引位置开始截取到字符串结尾 -
str.substring(int beginIndex,endIndex)指定截取的开始和结束位置,不包括endIndexString str = "hello world"; String str2 = str.substring(0,5);
-
-
trim() - 去除空格
str.trim()去除字符串前后的空格,而不是字符串内部的空格
-
replace() - 字符串替换
-
str.replace(char lodchar,char newchar)将指定的字符串替换成新的字符串String str = "hello world"; String str2 = str.replace("l","11"); // 会替换全部
-
-
大小写转换
-
将当前所以的字符串中的字符转换大小写
-
toLowerCase();
-
toUpperCase();
String str="asdfg"; System.out.println(str.toUpperCase());
-
-
第六章 package和final关键字
-
package关键字
- 注意事项 :
- 包名中字母一般要小写
- 包的命名规则
- package语句中必须是程序代码中的第一行可执行代码
package com.study.good
- 注意事项 :
-
import关键字
- 为了能够使用某个包的成员,需要在java程序中明确导入该包,使用"import"导包
- 格式 :
import 包名示例 :import com.study.good
-
final关键字
-
在java中,为了考虑安全因素,在设计类的时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会再被扩展,那么就设计为final类.它可以修饰类、方法和变量,表示最终的意思,即用它修饰的类|方法和变量后不可改变
-
特征 :
-
final修饰的类不能被继承
// 声明一个final类 Person final class Person { } // 声明Student类并集成Person类 //class Student extends Person { //} // 无法集继承 -
final修饰的方法不能被子类重写
class Person { public final void show() { } } // 声明Student类并集成Person类 class Student extends Person { // public void show() { // } // final修饰的方法不能被子类重写 } -
final修饰的变量是常量,初始化后不能被修改
- final修饰全局变量时,必须初始化赋值 :
final int i=2;
- final修饰全局变量时,必须初始化赋值 :
-
-
索引下标
```java
String str = "hello world";
char str2 = str.charAt(4);
```
-
substring() - 截取字符串
-
语法 :
str.substring(int beginIndex)利用字符串下标从指定的索引位置开始截取到字符串结尾 -
str.substring(int beginIndex,endIndex)指定截取的开始和结束位置,不包括endIndexString str = "hello world"; String str2 = str.substring(0,5);
-
-
trim() - 去除空格
str.trim()去除字符串前后的空格,而不是字符串内部的空格
-
replace() - 字符串替换
-
str.replace(char lodchar,char newchar)将指定的字符串替换成新的字符串String str = "hello world"; String str2 = str.replace("l","11"); // 会替换全部
-
-
大小写转换
-
将当前所以的字符串中的字符转换大小写
-
toLowerCase();
-
toUpperCase();
String str="asdfg"; System.out.println(str.toUpperCase());
-
第六章 package和final关键字
-
package关键字
- 注意事项 :
- 包名中字母一般要小写
- 包的命名规则
- package语句中必须是程序代码中的第一行可执行代码
package com.study.good
- 注意事项 :
-
import关键字
- 为了能够使用某个包的成员,需要在java程序中明确导入该包,使用"import"导包
- 格式 :
import 包名示例 :import com.study.good
-
final关键字
-
在java中,为了考虑安全因素,在设计类的时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会再被扩展,那么就设计为final类.它可以修饰类、方法和变量,表示最终的意思,即用它修饰的类|方法和变量后不可改变
-
特征 :
-
final修饰的类不能被继承
// 声明一个final类 Person final class Person { } // 声明Student类并集成Person类 //class Student extends Person { //} // 无法集继承 -
final修饰的方法不能被子类重写
class Person { public final void show() { } } // 声明Student类并集成Person类 class Student extends Person { // public void show() { // } // final修饰的方法不能被子类重写 } -
final修饰的变量是常量,初始化后不能被修改
-
final修饰全局变量时,必须初始化赋值 :
final int i=2; -
final修饰局部变量时,可以先声明,后赋值 :
finalint i; i=2;
-
-
-