在本文中，我们将详细介绍MySQL基础之标准模式通配符的各个方面，同时，我们也将为您带来关于7天学完Java基础之2/7、7天学完Java基础之4/7、7天学完Java基础之5/7、android基础
在本文中，我们将详细介绍MySQL 基础之 标准模式通配符的各个方面，同时，我们也将为您带来关于7 天学完 Java 基础之 2/7、7 天学完 Java 基础之 4/7、7 天学完 Java 基础之 5/7、android 基础之 XML 的创建与解析的有用知识。
本文目录一览：
MySQL 基础之 标准模式通配符
MySQL 标准魔兽通配符
作用：在搜索数据库中的数据时，SQL 通配符可以替代一个或多个字符
注意：标准模式 SQL 通配符必须与 LIKE 运算符一起使用
1、% 通配符
作用：匹配一个或多个字符。
找出以 “en” 结尾的名字
mysql> SELECT * FROM information WHERE name LIKE ''%en'';
+------+----------+---------------+----------+
| id | name | address | city |
+------+----------+---------------+----------+
| 1002 | xiaochen | Oxford street | New York |
+------+----------+---------------+----------+
1 row in set (0.00 sec)找出城市名中包含 “Y” 的字符
mysql> SELECT * FROM information WHERE city LIKE ''%Y%'';
+------+----------+---------------+----------+
| id | name | address | city |
+------+----------+---------------+----------+
| 1002 | xiaochen | Oxford street | New York |
+------+----------+---------------+----------+
1 row in set (0.00 sec)2、_ （下划线）仅替代一个字符
mysql> SELECT * FROM information WHERE city LIKE ''_ew_York'';
+------+----------+---------------+----------+
| id | name | address | city |
+------+----------+---------------+----------+
| 1002 | xiaochen | Oxford street | New York |
+------+----------+---------------+----------+
1 row in set (0.00 sec)这里第一个下划线替代一个字符 “N”，第二个下划线替代字符 “空格”
我们上面的查询是非常简单的那种，接下来我们学习一下扩展正则表达式查询
7 天学完 Java 基础之 2/7
面向对象
面向对象的思想就是值我们要实现一个共功能的时候，我们不自己去做，而是找别人帮我们去做，帮我们去做的这个人就是对象。面向对象强调的是谁来帮我实现这个功能。
类与对象的关系
类：是一组相关属性和行为的集合，类可以看成是事物的模板
对象：对象是一类事物的具体体现，对象是类的一个实列，必然具备该类的事物属性和行为。
类是对象的模板，对象是类的实体
下面来定义一个学生类
//类具有属性和行为，属性也叫做成员变量，行为也叫做成员方法
public class Student{
//定义成员变量,因为每一个学生都有不同的姓名和年龄，所以可以把这两个作为成员变量,成员变量要定义在类中，方法外面，如果定义在方法里面，就叫做局部变量。变量是有作用域的，成员变量的作用域在整个类中，局部变量的作用域在该方法的里面。
String name;
int age;
//定义方法，每一个学生都有着吃饭，睡觉，学习的行为，也就是方法
public void eat(){
System.out.println("我是"+name+"在吃饭");
}
public void sleep(){
System.out.println("我是"+name+"在睡觉");
}
public void study(){
System.out.println(name+"今年"+age+"岁了，要认真学习了");
}
}
刚刚定义好了类，现在让我们来使用他吧
类的使用需要创建对象
//创建对象的格式
//类的名称 对象名 = new 类名称();
//成员变量的使用 对象名.成员变量
//成员方法的使用 对象名.成员方法()
public class AStudent{
public static void main(String[] args){
/*创建Student类对象，对象创建好之后就可以使用类了，也就是说可以
使用对象名去调用类的成员方法，还可以对该类的成员变量赋值*/
Student stu = new Student();
//对成员变量赋值,将右侧的刘备赋值交给stu对象当中的name成员变量
stu.name = "刘备";
stu.age = "18";
//调用成员方法
stu.eat();
stu.sleep();
stu.study();
}
}
使用对象类型作为方法的参数
什么是对象类型，new 出来的就是对象类型
public class AStudent{
public static void main(String[] args){
Student one = new Student();
one.age = 18;
one.name = "新垣结衣";
method(one);
}
//以Student类做为参数传递，传递进来的对象中的方法和变量可以使用param参数名称来调用
public static void method(Student param) {
System.out.println(param.name);//新垣结衣
System.out.println(param.age);//18
param.study();//新垣结衣今年18岁了，要认真学习了
}
}
使用对象类型作为方法的返回值
public static void main(String[] args){
//返回值类型是一个Student，所以需要Student来接收该返回值
Student two = method();//method()方法的返回值类型是Student;
two.study();
}
public static Student method() {
Student one = new Student();
one.name="曹操";
one.age = 90;
return one;
局部变量与成员变量的不同
-
定义的位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
-
作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类都可以通用
-
默认值不一样
局部变量：没有默认值，如果想使用，必须要手动赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
面向对象的三大特征之封装性
- 方法就是一种封装
- 关键字 private 也是一种封装
封装就是将一些细节信息隐藏起来，对于外界不可见
private 关键字一旦用于成员变量，那么该成员变量就只能够在本来中访问，不能再其它类中访问
public class Student{
String name;
//写在对age设置private，使他只能够再本类中访问
private int age;
public void setAge(int num){
//未来避免年龄传入进来的不合理加上if判断语句
//条件为真就把num赋值给age
if(0<num&&num<150){
age = num;
}else{
System.out.println("年龄不合理")；
}
}
public int getAge(){
return age;
}
}
现在写多一个类来间接访问 age;
public class AStudent{
public static void main(String[] args){
//创建了Student对象，就可以使用她的变量和方法了
Student one = new Student();
//调用了方法setAge.传递了参数
one.setAge(18);//int age = 18;
//设置了private的要通过setAge来访问，没有设置private的可以直接对象名.成员变量来访问
System.out.println(one.name+" "+one.getAge());
}
}
构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字 new 来创建对象是，其实就是再调用构造方法，构造方法的名称必须和所在类的名称完全一样，构造方法不要写返回值类型。
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，没有方法体。
一旦自己编写了构造方法，那么编译器将不会给你赠送构造方法
格式：
public 类名称（参数类型 参数名称）{方法体}
public class Student{
public Student(//我是参数){
System.out.println("构造方法被调用了");//我是方法体
}
}
//new 对象就是在调用构造方法
public class AStudent{
public static void main(String[] args){
//构造方法new对象的时候就被执行
Student stu = new Student();//创建Student对象，就是在调用Student的构造方法
//运行程序将会得到 构造方法被调用了
}
}
定义一个标准类
//new 对象就是在调用构造方法
public class AStudent{
public static void main(String[] args) {
Student one = new Student();
one.setAge(20);
one.setName("孙权");
System.out.println("姓名--"+one.getName()+" 年龄--"+one.getAge());
Student two = new Student("曹操",30);
System.out.println("姓名--"+two.getName()+" 年龄--"+two.getAge());
}
}
7 天学完 Java 基础之 4/7
静态 static
如果一个成员变量使用了 static 关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据
静态 static 关键字修饰成员变量
public class Student {
private String name;
private int age;
static String room;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public static void main(String[] args){
Student one = new Student("郭靖",18);
//用对象名.变量名给变量赋值
one.room = "101";
Student two = new Student("黄蓉",16);
//姓名:郭靖 年龄18 教室105
System.out.println("姓名:" +one.getName()+" 年龄"+one.getAge()+" 教室"+one.room);
//没有对two.room赋值但是也输出了教室101,可见被static修饰过的变量的数据是共享的
//姓名:黄蓉 年龄16 教室105
System.out.println("姓名:" +two.getName()+" 年龄"+two.getAge()+" 教室"+two.room);
}
静态 static 关键字修饰成员方法
一旦使用 static 修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的
如果没有 static 关键字，那么必须首先创建对象，然后通过对象才可以使用他
有 static 关键字可以通过类名。静态方法名调用方法
public class MethodDemo {
public void method(){
System.out.println("这是一个成员方法");
}
public static void method1(){
System.out.println("这是一个静态方法");
}
}
public class MethodTest {
public static void main(String[] args){
MethodDemo one = new MethodDemo();
//对象名调用方法
one.method();
//对象名调用方法
one.method1();
//类名调用静态方法
MethodDemo.method1();
}
如果有了 static，都推荐使用类名称来调用
注意事项
- 静态不能直接访问非静态
public class MethodDemo {
int num ;
static int num1;
public void method(){
System.out.println("这是一个成员方法");
//成员方法访问成员变量和静态变量
System.out.println(num);
System.out.println(num1);
}
public static void method1(){
System.out.println("这是一个静态方法");
//静态方法访问静态变量
System.out.println(num1);
//静态方法不能够访问非静态变量
//System.out.println(num);编译报错
}
- 静态方法不能使用 this，因为 this 代表当前对象，而静态方法属于类。
静态代码块
特点，当第一次用到本来的时候，静态代码块执行唯一一次
/*格式
public class 类名{
static{}
}*/
public class StaticDemo {
static{
System.out.println("静态代码块执行了");
}
public StaticDemo(){
System.out.println("构造方法执行了");
}
}
public class StaticDemotest {
public static void main(String[] args) {
//静态代码块只会执行一次，并且优先于其他语句执行
StaticDemo one =new StaticDemo();
StaticDemo two = new StaticDemo();
}
}
//输出结果
静态代码块执行了
构造方法执行了
构造方法执行了
Arrays 工具类
public static String toStirng (数组), 将参数数组变成字符串
public static void main(String[] args) {
int[] arrays= new int[]{1,2,3,4,5};
String[] arrays1 = new String[]{"骐骥一跃","不能十步","驽马十驾","功在不舍"};
//调用Arraysd的toString方法把数组变成字符串
String str = Arrays.toString(arrays);
String str1 = Arrays.toString(arrays1);
//打印字符串
System.out.println(str);
System.out.println(str1);
}
public static void sort (数组), 按照默认升序，对数组元素排序
public static void main(String[] args) {
int[] arrays= new int[]{1,63,45,55,88};
String[] arrays1 = new String[]{"骐骥一跃","不能十步","驽马十驾","功在不舍"};
//对数组进行排序
Arrays.sort(arrays);
Arrays.sort(arrays1);
//排序完之后，把他变成字符串，打印输出
System.out.println(Arrays.toString(arrays));
System.out.println(Arrays.toString(arrays1));
//输出结果如下
//[1, 45, 55, 63, 88]
//[不能十步, 功在不舍, 驽马十驾, 骐骥一跃]
}
Arrays 字符串倒序练习
public static void main(String[] args) {
//先创建一个字符串
String str = "ERsdf485dfW";
//要排序字符串，需要把字符串变成char数组，可以使用toCharArray方法
char[] chars = str.toCharArray();
//把字符串用sort方法排序好
Arrays.sort(chars);
//然后就可以for循环遍历来倒序
//chars数组的最大索引为长度减一，索引为0也有元素，索引需要>=0
for(int i=chars.length-1;i>=0;i--){
System.out.println(chars[i]);
}
}
继承
继承的格式
public class zi extends fu{}
继承中成员变量的访问特点
在子父类的继承关系当中，如果有成员变量重名，则创建子类对象时，访问有两种方式
直接通过子类对象访问成员变量
等号左边是谁，就优先有谁，没有则向上找
public class Fu {
//父类
int num = 100;
}
public class Zi extends Fu{
//子类
int num = 200;
}
public static void main(String[] args) {
Zi zi = new Zi();
//输出的时100还是200？
System.out.println(zi.num);//200
}
间接通过成员方法访问成员变量
方法属于谁，就优先用谁，没有则向上找
public class Fu {
//父类
int num = 100;
public void methodFu(){
System.out.println(num);
}
}
public class Zi extends Fu{
int numZi = 10;
int num = 200;
public void methodzi(){
System.out.println(num);
}
public static void main(String[] args) {
Zi zi = new Zi();
//输出的时100还是200？
System.out.println(zi.num);//200
//这个方法是子类的，优先使用子类的成员变量
zi.methodzi();//200
//这个方法是父类的，优先使用父类的成员变量
zi.methodFu();//100
}
区分子类方法中重名的三种变量
public class Fu {
int num = 10;
}
public class Zi extends Fu{
int num = 20;
public void method(){
int num = 30;
//输出局部变量
System.out.println(num);
//输出本类变量
System.out.println(this.num);
//输出父类变量
System.out.println(super.num);
}
}
/*
*局部变量:
* 本类的成员变量
* 父类的成员变量
* */
public class ExtendsTest {
public static void main(String[] args) {
Zi zi = new Zi();
//调用Zi类方法
zi.method();
}
}
继承中成员方法的访问特点
public class Fu {
public void methodFu(){
System.out.println("父类方法");
}
public void method(){
System.out.println("父类重名方法执行");
}
}
public class Zi extends Fu{
public void methodZi(){
System.out.println("子类方法执行");
}
public void method(){
System.out.println("子类重名方法执行");
}
}
public class ExtendsTest {
public static void main(String[] args) {
Zi zi = new Zi();
//调用Zi类方法
zi.methodFu();
zi.methodZi();
//方法重名，优先使用子类方法
zi.method();
}
}
重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样
重写（Override），方法的名称一样，参数列表也一样
重载（Overload），方法的名称一样，参数列表不一样
继承中构造方法的访问特点
public class Fu {
public Fu(){
System.out.println("我是无参数的父类构造方法");
}
public Fu(int num){
System.out.println("我是有参数的父类重载构造");
}
}
public class Zi extends Fu{
public Zi(){
//在继承关系中，编译器都会默认赠送一个super()父类构造方法;
//而且还是在子类构造方法的第一行，所以在new对象的时候会先执行
// 父类的构造方法
// super();
super(5);
//在继承关系中，子类会有一个默认的super();
System.out.println("子类构造方法");
}
}
/*
继承关系中，父子类构造方法的访问特点
1.子类构造方法当中有一个默认隐含的"super()"调用
2.子类构造可以通过super关键字来调用父类重载构造
super的父类构造调用，必须在构造方法的第一句
*/
public class ConstructorDemo {
public static void main(String[] args) {
Zi zi = new Zi();
//父类构造方法
//子类构造方法
}
}
super 关键字的三种用法
1. 在子类的成员方法中，访问父类的成员变量。super.numFu
2. 在子类的成员方法中，访问父类的成员方法。super.methodFu
3. 在子类的构造方法中，访问父类的构造方法。
this 关键字的三种用法
super 关键字用来访问父类内容，而 this 关键字用来访问本类内容，用法也有三种
1. 在本类中的成员方法中，访问本类的成员变量
public class Zi extends Fu {
int num = 55;
public void athis() {
int num = 66;
System.out.println(num);//66
System.out.println(this.num);//55
}
}
2. 在本类的成员方法中，访问本类的另一个成员方法，
int num = 55;
public void athis() {
int num = 66;
System.out.println(num);//66
System.out.println(this.num);//55
}
public void bthis(){
System.out.println("bbb");
}
public void cthis(){
this.athis();
System.out.println("ccc");
}
public static void main(String[] args) {
new Zi().cthis();//输出结果为66 55 ccc
}
3. 在本类的构造方法中，访问本类的另一个构造方法
public Zi(){
//重载构造方法两个
//调用下一个构造方法
this(123);
}
public Zi(int n){
//调用下一个构造方法
this(1,2);
}
public Zi(int a,int b){
}
//注意this()调用跟super()一样也必须是构造方法的第一个语句，super和this两张构造调用，不可以同时使用。
练习
public class Fu {
int num = 5;
public Fu(){
System.out.println("我是构造方法");
}
public void method(){
System.out.println("我是父类");
}
}
public class Zi extends Fu {
int num = 6;
public void method1(){
int num = 7;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
@Override
public void method(){
super.method();
System.out.println("我是子类");
}
}
public class ConstructorDemo {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method1();
zi.method();
//我是构造方法
//7
//6
//5
//我是父类
}
}
Java 继承的三个特点
1.Java 语言是单继承的，一个类的直接父类只有由唯一一个
- Java 语言可以多级继承，也就是 A 类继承 B 类，B 类继承 C 类
- 一个类的直接父类是唯一的，但是父类可以由很多个子类，
抽象类
public abstract class 类名{
public abstract void 方法名(){}
//抽象类中也可以定义普通成员方法
public void 方法名(){}
}
抽象方法和抽象类的使用
- 抽象类不能够直接 new 的抽象类对象
- 必须用一个子类继承抽象类才可以使用
- 子类必须重写抽象父类当中的所有抽象方法
- 创建子类对象进行使用
抽象方法和抽象类的注意事项
-
抽象类不能够创建对象
-
抽象类，可以有构造方法的，是供子类创建对象时，初始化成员使用的
-
抽象类中，不一定包含抽象方法，但是抽象方法一定包含在抽象类中
-
抽象类的子类，必须重写抽象父类的所有抽象方法
红包案例
public class AUser {
private int money ;
private String name ;
public AUser() {
}
public AUser(int money, String name) {
this.money = money;
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("我"+name+"现在的余额是"+money);
}
}
import java.lang.reflect.Array;
import java.util.ArrayList;
public class Admin extends AUser{
public Admin() {
}
public Admin(int aBalance, String aName) {
super(aBalance, aName);
}
public ArrayList<Integer> send(int totalMoney, int count){
ArrayList<Integer> redList = new ArrayList<>();
int i= totalMoney/count;
//判断群主有多少钱
int leftMony = super.getMoney();
if(totalMoney>leftMony){
System.out.println("余额不足");
return redList;
}
//扣钱
super.setMoney(leftMony -totalMoney);
int avg = totalMoney/count;
int mod = totalMoney%count;
for(int d=0;d<count-1;d++){
redList.add(avg);
}
int last= avg+mod;
redList.add(last);
return redList;
}
}
import java.util.ArrayList;
import java.util.Random;
public class Menber extends AUser{
public Menber() {
}
public Menber(int money, String name) {
super(money, name);
}
public void receive(ArrayList<Integer> list){
int index = new Random().nextInt(list.size());
int delta = list.remove(index);
int money = super.getMoney();
super.setMoney(money+delta);
}
}
import java.util.ArrayList;
public class RedPacket {
public static void main(String[] args) {
Admin admin = new Admin(100,"群主");
Menber one = new Menber(0,"aaa");
Menber two = new Menber(0,"aaa");
Menber three = new Menber(0,"aaa");
admin.show();
one.show();
two.show();
three.show();
ArrayList<Integer> redList = admin.send(20,3);
one.receive(redList);
two.receive(redList);
three.receive(redList);
admin.show();
one.show();
two.show();
three.show();
}
}
7 天学完 Java 基础之 5/7
接口
接口就是一种公共的规范标准 是一种引用数据类型
定义格式
public interface 接口名称 {}
java7 中接口可以包含常量，抽象方法；Java8 还可以额外包含默认方法，静态方法；Java 9 还可以额外包含私有方法
public interface MyInterfaceAbstract{
//这是一个抽象方法
public abstract void methodAbs();
//接口中的抽象方法，修饰符必须是两个固定的关键字:public abstract
//这两个关键字可以选择性的省略
abstract void methodAbs2();
public void methodAbs3();
void methodAbs4();
}
接口的抽象方法使用
接口使用步骤：
-
接口不能够直接使用，必须有一个 “实现类” 来实现该接口
格式：
public class 实现类名称 implements 接口名称 {}
-
接口的实现类必须覆盖重写接口中所有的抽象方法
-
创建实现类对象 (new)，进行使用
//按照定义格式定义一个接口
//public interface 接口名称{}
public interface InterfaceDemo {
//接口里面可以有抽象方法，普通方法
//定义一个抽象方法
public abstract void methodAbs1();
//默认方法
public abstract void methodAbs2();
}
public class InterfaceDemoImpl implements InterfaceDemo{
//回顾一些重写的概念
//方法名和形参列表一样
//权限修饰符必须大于或者等于父类的权限修饰符
//子类的返回值类型必须小于或者等于父类的返回值类型
@Override
public void methodAbs1() {
System.out.println("天下武功，唯快不破");
}
@Override
public void methodAbs2() {
System.out.println("认真的人，自带光芒");
}
}
public class newInterfaceDemo {
public static void main(String[] args){
InterfaceDemoImpl inter = new InterfaceDemoImpl();
inter.methodAbs1();
inter.methodAbs2();
}
}
注意事项
如果实现类并没有覆盖重写接口中的所有的抽象方法，那么这个实现类就必须是抽象类
接口的默认方法定义
public interface InterfaceDemo {
/*
java 8开始，接口允许定义默认方法
格式:
public default 返回值类型 方法名称（参数列表）{
方法体
}
备注:接口当中的默认方法，可以解决接口升级的问题
默认方法可以有方法体
*/
public abstract void methodAbs1();
public default void methodAbs2(){
System.out.println("我是默认方法，可以解决升级问题");
}
public class InterfaceDemoImpl implements InterfaceDemo{
@Override
public void methodAbs1() {
System.out.println("天下武功，唯快不破");
}
//我在这里并没有重写public default void methodAbs2()
//实现接口自动继承方法
}
public class newInterfaceDemo {
public static void main(String[] args){
InterfaceDemoImpl inter = new InterfaceDemoImpl();
//接口的默认方法也是可以覆盖重写的
//这里就不写了
inter.methodAbs1();
inter.methodAbs2();
}
}
接口的静态方法的定义
/*
格式
public static 返回值类型 方法名称（参数列表）{}
*/
public interface InterfaceStatic {
public static void method1(int a,int b){
System.out.println("今天要敲"+a*b+"行代码");
}
}
public class InterfaceStaticImpl {
//接口中的静态方法的使用
public static void main(String[] args) {
//直接通过接口名称.静态方法的名称调用即可
InterfaceStatic.method1(15,67);
}
}
接口的私有方法定义
/*
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题
但是这个共有方法，不应该被是实现类使用，应该私有化的
解决方案
从Java 9 开始，接口当中允许定义私有方法
1.普通私有方法，解决多个默认方法之间重复代码问题
格式
private 返回值类型 方法名称(参数列表){}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称（参数列表）{}
*/
public interface InterfaceStatic {
public default void method1(){
System.out.println("认真的人，自带光芒");
method3();
}
public default void method2(){
System.out.println("作日的最佳表现，是今日的最低要求");
method3();
}
private void method3(){
System.out.println("乘风破浪会有时，直挂云帆济沧海");
}
}
public class InterfaceStaticImpl implements InterfaceStatic{
public static void main(String[] args) {
InterfaceStaticImpl inter = new InterfaceStaticImpl();
inter.method1();
inter.method2();
//接口中的静态方法的使用
//想要使用接口的方法，必须要实现接口
//实现完接口后，需要new对象使用
}
}
接口的常量定义和使用
1. 接口当中的常量，可以省略 public static final , 注意，不写也照样是这样
-
接口当中的常量，必须进行复制，不赋值不能使用
-
接口当中的常量名称，使用完全大写的字母，用下划线进行分割
使用格式
接口名称。常量名称
多态
多态的前提：extends 继承或者 Implements 实现，
一个对象拥有多种形态，这就是：对象的多态性
代码当中体现多态性：父类引用指向子类对象
多态格式
父类名称 对象名 = new 子类名称（）；
或者
接口名称 对象名 = new 实现类名称（）；
多态中成员变量的使用特点
//访问成员变量的两种方式
//1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有向上找
//2.间接通过成员方法访问
public class Fu {
//子类也有相同的成员变量num
int num = 10;
public void shownum(){
System.out.println(num);
}
}
public class Zi extends Fu{
//与父类相同的成员变量num
int num = 20;
//子类特有的成员变量
int num1 =30;
//重写方法
@Override
//重写了父类的方法，
public void shownum(){
System.out.println(num);
}
}
public class Demo01MultiField {
public static void main(String[] args) {
//使用多态的写法，父类引用指向子类对象
Fu obj = new Zi();
//等号左边是Fu，优先使用左边的的成员变量，没有则向上找
System.out.println(obj.num);//10
//不可能向下找
//System.out.println(obj.num1);编译报错
//shownum属于Fu，则使用Fu的成员变量//10
//当子类覆盖重写父类，就属于Zi类//20
obj.shownum();
}
}
多态中成员方法的使用特点
public class Fu {
//成员方法的访问规则
//看new的是谁，就优先用谁，没有则向上找
public void method(){
System.out.println("我是父类");
}
public void methodFu(){
System.out.println("我是父类特有方法");
}
}
public class Zi extends Fu{
public void method(){
System.out.println("我是子类");
}
public void methodZi(){
System.out.println("我是子类特有方法");
}
}
java
public class Demo01MultiField {
public static void main(String[] args) {
Fu obj = new Zi();//多态
obj.method();// 父子都有，new的是zi，优先用zi //输出结果我是子类
obj.methodFu();//子类没有，向上找， //输出结果我是父类特有方法
}
}
多态中成员变量访问规则和成员方法访问规则总结
成员变量：看左边，左边是哪一个类就优先使用哪一个类。没有像上找
成员方法：看右边，new 的是哪一个对象就优先使用哪一个对象的方法。没有向上找
对象的向上转型
-
对象的向上转型，其实就是多态的写法
格式 父类名称 对象名 = new 子类名称（）;
含义：右侧创建一个子类对象，把他当作父类来看待使用
Animal animal = new Cat (); 创建了一只猫，当作动物看待
注意事项：向上转型一定是安全的从小范围（猫）转成大范围（动物）
对象的向下转型
对象的向下转型，其实是一个还原的动作
格式：子类名称 对象名 = （子类名称）父类对象；
含义，将父类对象，还原成本来的子类对象
Animal animal = new Cat();//本来是猫，向上转型成为动物
Cat cat = (cat) animal;//本来是猫，已经被当成动物了，还原回来成为本来的猫向下转型；
instanceof 关键字进行类型判断
格式：
对象 instanceof 类名称
这将会得到一个 Boolean 值结果，也就是判断前面的对象能不能当作后面类型的实例
笔记本 USB 接口案例
//先确定一下笔记本电脑有什么功能
//关机，开机，可以使用各种USB设备
//功能确定好之后写方法
public class Computer {
public void powerOn() {
System.out.println("笔记本电脑开机了");
}
public void powerOff() {
System.out.println("笔记本电脑关机了");
}
public void usbDevice(USB usb) {
usb.open();
if (usb instanceof Mouse) {
Mouse mouse = (Mouse) usb;
mouse.click();
} else if (usb instanceof KeyBoard) {
KeyBoard keyboard = (KeyBoard) usb;
keyboard.type();
}
//usb.close();
}
}
//usb设备需要设置成接口，并且有抽象方法，
//因为usb设备都有着共性的方法，和非共性的方法，我们需要把共性的方法给抽取出来
//usb设备都有开关的功能
public interface USB {
//打开设备的功能
public abstract void open();
//关闭设备的功能
public abstract void close();
}
//现在设置一个usb设备
//去实现USB接口
//实现了这个USB接口才可以在Computer类中传递进去，有了USB设备，鼠标才是一个完整的电脑
//现在就去实现这个接口吧
public class Mouse implements USB {
//必须重写抽象方法
@Override
public void open() {
System.out.println("鼠标插入");
}
@Override
public void close() {
System.out.println("鼠标拔出");
}
//鼠标特有的方法
public void click() {
System.out.println("鼠标点击");
}
}
//也是一个USB设备
public class KeyBoard implements USB {
//重写方法
@Override
public void open() {
System.out.println("键盘插入。。。");
}
@Override
public void close() {
System.out.println("键盘拔出");
}
//键盘特有方法
public void type() {
System.out.println("键盘打字");
}
}
//现在可以创建一个计算机了
public class ComputerImple {
public static void main(String[] args) {
//创建一个笔记本对象
Computer computer = new Computer();
//启动笔记本
computer.powerOn();
//创建USB接口
USB usb = new Mouse();
//传递接口
computer.usbDevice(usb);
USB usb1 = new KeyBoard();
computer.usbDevice(usb1);
//关闭笔记本
computer.powerOff();
}
}
android 基础之 XML 的创建与解析
写一个很简单的例子记录一下 XML 的创建与解析。
创建与解析其实是两个互逆的过程，会了其中一个对应的就能写出来。
创建用 XmlSerializer xmlSerializer=Xml.newSerializer ();
解析用 XmlPullParser xmlPullParser=Xml.newPullParser ();
package com.example.xmlborn;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;
import android.R.xml;
import android.os.Bundle;
import android.app.Activity;
import android.util.Xml;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity implements OnClickListener{
Button xmlpullButton;
private String result;
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String resource=produceXML();
textView=(TextView) findViewById(R.id.text);
xmlpullButton=(Button) findViewById(R.id.button1);
xmlpullButton.setOnClickListener(this);
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
switch (v.getId()) {
case R.id.button1:
result=parseXML();
if (result!=null) {
textView.setText(result);
}else {
Toast.makeText(getApplicationContext(),"null",1000).show();
}
break;
default:
break;
}
}
private String produceXML() {
// TODO Auto-generated method stub
StringWriter writer=new StringWriter();
XmlSerializer xmlSerializer=Xml.newSerializer();
ArrayList<Beauty> list=getData();
try {
xmlSerializer.setOutput(writer);
xmlSerializer.startDocument("UTF-8",true);
xmlSerializer.startTag(null,"beauties");
for (Beauty beauty:list) {
xmlSerializer.startTag(null,"beautyname");
xmlSerializer.text(beauty.getNameString());
xmlSerializer.endTag(null,"beautyname");
xmlSerializer.startTag(null,"age");
xmlSerializer.text(beauty.getAge());
xmlSerializer.endTag(null,"age");
}
xmlSerializer.endTag(null,"beauties");
xmlSerializer.endDocument();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return writer.toString();
}
private ArrayList<Beauty> getData() {
// TODO Auto-generated method stub
ArrayList<Beauty> list=new ArrayList<Beauty>();
Beauty lily=new Beauty("lily","23");
Beauty lucy=new Beauty("lucy","36");
list.add(lily);
list.add(lucy);
return list;
}
private String parseXML() {
result="通过pull解析结果为：";
String xmlString=produceXML();
StringReader in=new StringReader(xmlString);
XmlPullParser xmlPullParser=Xml.newPullParser();
try {
xmlPullParser.setInput(in);
int type=xmlPullParser.getEventType();
while (type!=XmlPullParser.END_DOCUMENT) {
String nodeName=xmlPullParser.getName();
switch (type) {
case XmlPullParser.START_TAG:
if("beautyname".equals(nodeName)){
result +="姓名："+xmlPullParser.nextText();
}if ("age".equals(nodeName)) {
result +="年龄:"+xmlPullParser.nextText();
}
break;
}
type=xmlPullParser.next();
}
} catch (XmlPullParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return result;
// TODO Auto-generated method stub
}
class Beauty{
String nameString,age;
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public Beauty(String nameString, String age) {
super();
this.nameString = nameString;
this.age = age;
}
}今天的关于MySQL 基础之 标准模式通配符的分享已经结束，谢谢您的关注，如果想了解更多关于7 天学完 Java 基础之 2/7、7 天学完 Java 基础之 4/7、7 天学完 Java 基础之 5/7、android 基础之 XML 的创建与解析的相关知识，请在本站进行查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
