1构造代码块和static案例
1,1分析过程
计数器
记录用户的登录次数，当前网站访问人数。。。
自动生成用户ID号
会员ID号不可以重复，而且是用户在申请账号时自动生成！！!
分析
1程序不退出，ID号始终处于一种记录状态，保存下一个用户的ID号
2用户提供不管多少数据，都要给予一个对应的ID号
解决
ID号始终处于一种记录状态
1这里需要一个变量来保存ID号
int类型
局部变量：
局部变量在方法内，方法运行结束，局部变量销毁，无法作为持久化保存【不能使用】
成员变量：
成员变量保存在对象之中，每一个对象保存的数据是不一样的
而且需要操作对象来进行获取，对象是存在可能性在一定条件下被销毁的
不具有持久性，操作较为繁琐
静态成员变量：
整个代码运行周期都存在，和对象无关，可以直接通过类名操作，该变量保存在内存数据区，是一个共享资源
2用户提供不管多少数据，都要给予一个对应的ID号
用户使用不同的构造方法，都要能够赋值对应ID号，ID号不是用户提供的！！！
构造代码块不关你调用那一个new + 构造方法，都要执行对应的操作
package com.qfen.rxs;
public class Vip {
private int id;
private String name;
private int age;
private String address;
private static int count = 1;
{
id = count;
count += 1;
}
public Vip() {}
public Vip(String name) {
this.name = name;
}
public Vip(String name, int age) {
this.name = name;
this.age = age;
}
public Vip(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public static int getCount() {
return count;
}
public static void setCount(int count) {
Vip.count = count;
}
@Override
public String toString() {
return "Vip [id=" + id + ",nmae" + name + ",age= " +age+",address=" + address + "]";
}
}
2接口【重点】
2.1java中定义接口的格式
关键字：
interface 接口
UI Design User Interface
格式：
interface 接口名{
成员变量
成员方法
}
要求
1接口名大驼峰命名法
2成员变量【缺省属性】public static final定义时必须要初始化
3成员方法【缺省属性】public abstract 方法没有方法体
interfaceA{
int num = 10；
void test（）；
}
2.2java中类【尊从】接口格式
关键字
impments
格式：
class A impments B {
}
A类是B接口的实现类
A类尊从B接口
2.3一个类可以同时遵从多个接口
package com.qfen.rxs;
interface C{
void testC();
}
interface D{
void testD();
}
interface E{
void testE();
}
class F implements C,D,E{
@Override
public void testC() {
System.out.println("遵从接口E，实现testC方法");
}
@Override
public void testD() {
System.out.println("遵从接口E，实现testD方法");
}
@Override
public void testE() {
System.out.println("遵从接口E，实现testE方法");
}
}
public class Demo2 {
}
2.4接口可以继承接口
关键字
extends
package com.qfen.rxs;
interface Usb1_0{
void usb1_0();
}
interface Usb2_0{
void usb2_0();
}
interface Usb3_0{
void usb3_0();
}
interface UsbMi extends Usb1_0, Usb2_0, Usb3_0 {
void usbMi();
}
class MiGameComputer implements UsbMi {
@Override
public void usb1_0() {
System.out.println("兼容USB1.0");
}
@Override
public void usb2_0() {
System.out.println("兼容USB2.0");
}
@Override
public void usb3_0() {
System.out.println("兼容USB3.0");
}
@Override
public void usbMi() {
// TODO Auto-generated method stub
}
}
public class Demo3 {
public static void main(String[] args) {
new MiGameComputer().usb1_0();
new MiGameComputer().usb2_0();
new MiGameComputer().usb3_0();
}
}
2.5abstract类遵从接口
abstract修饰的方法
1没有方法体
2必须定义在abstract修饰的类中，或者interface接口内
package com.qfen.rxs;
interface Servlet {
void init();
void service();
}
abstract class BaseServlet implements Servlet{
@Override
public void init() {
System.out.println("BaseServlet实现init方法");
}
}
class MyServlet extends BaseServlet {
@Override
public void service() {
System.out.println("MyServlet实现Servlet方法");
}
}
class MyServlet2 extends BaseServlet {
@Override
public void service() {
System.out.println("MyServlet2实现Servlet方法");
}
}
public class Demo4 {
public static void main(String[] args) {
new MyServlet().init();
new MyServlet().service();
new MyServlet2().init();
new MyServlet2().service();
}
}
2.6JDk1.8新特征default关键字
default关键字可以在接口中使用，用于修饰方法，使用default关键字修饰的方法在接口中是允许有方法体
【默认方法】【非强制重写方法】
package com.qfen.rxs;
interface DefaultInterface {
void test();
default public void testDefault() {
System.out.println("testDefault() 默认方法非强制重写方法");
}
default public void defaultMethod() {
System.out.println("defaultMethod() 默认方法非强制重写方法");
}
}
class Demo implements DefaultInterface {
@Override
public void test() {
System.out.println("强制实现的test方法");
}
@Override
public void testDefault() {
System.out.println("实现类重写default方法");
}
}
public class Demo5 {
public static void main(String[] args) {
new Demo().test();
new Demo().testDefault();
new Demo().defaultMethod();
}
}
3多态【重点】
package com.qfen.rxs;
class Animal {
}
class Tiger extends Animal {
}
class Panda extends Animal {
}
class Monkey extends Animal {
}
public class Demo6 {
public static void main(String[] args) {
Animal animal = new Animal();
Tiger tiger = new Tiger();
Panda panda = new Panda();
Monkey monkey = new Monkey();
showAnimal(animal);
showAnimal(tiger);
showAnimal(panda);
showAnimal(monkey);
Panda p = (Panda)getAnimal();
//Animal animal1 = getAnimal();
System.out.println(p);
}
private static Panda getAnimal() {
// TODO Auto-generated method stub
return new Panda();
}
private static void showAnimal(Animal animal) {
// TODO Auto-generated method stub
System.out.println(animal);
}
}
3.2小总结
1一个方法需要的参数是父类，传入实际参数是父类对象本身，或者其子类对象都是Ok的
2一个方法返回值类型是父类，实际返回的数据时父类对象本身或者其子类对象也是Ok
3引用数据类型之间的强制类型转换时语序使用，但是要求明确真实数据类型是一致的，不然会导致异常ClassCastException
package com.qfen.rxs;
interface USB {
void connect();
}
class Mouse implements USB {
@Override
public void connect() {
System.out.println("鼠标控制光标");
}
}
class Logi extends Mouse {
@Override
public void connect() {
System.out.println("Logi Master 2S");
}
}
class Keyboard implements USB {
@Override
public void connect() {
System.out.println("键盘敲代码");
}
}
class IKBC extends Keyboard {
@Override
public void connect() {
System.out.println("IKBC C87 ");
}
}
class Computer {
public void useUSBInterface(USB usb) {
usb.connect();
}
}
public class Rxs {
public static void main(String[] args) {
Computer computer = new Computer();
Mouse mouse = new Mouse();
Keyboard keyboard = new Keyboard();
computer.useUSBInterface(mouse);
computer.useUSBInterface(keyboard);
computer.useUSBInterface(new Logi());
computer.useUSBInterface(new IKBC());
}
}
3.3总结
1一个方法需要的参数是usb接口但是传入的对象时USB接口的直接实现类或者间接实现类都是可以的
2代码整个过程中是完全符合生活逻辑
3.4这其实是多态【背】
1父类的引用指向子类的对象
2或者接口的应用指向遵从接口的类对象