标签：
this指针在类定义时用到，this属于用类实例化的对象，只能在定义类的时候使用；(在下面的代码中会有体现)
定义： 访问修饰符 static+数据类型+变量名
所有该类的对象均可访问，均可修改，不会在调用后初始化，相当于全局变量。
可以被所有对象访问到，并且可以通过类访问到 类名.类变量
静态方法 == 类方法
可以被类名和对象访问到
原则上类变量用类方法来访问
类方法中不能访问非类变量，类变量可以被非类方法访问。
四种访问控制符：
public ： 对外公开
private：仅对本身公开
无： 向同一个包中的类公开
protected：对子类和同一个包中的类公开
同一个包中不能有同名的函数，包括类中的方法；
包名都是小写字母和下划线组成
作用：
区分相同名的类
对很多包进行管理
控制访问的范围
打包命令： package com.~~~ 创建包时添加在同一个包的各个类文件的头部；
常用的包： java.lang.* 自动引入
java.util.* 工具包
java.net.* 网络开发包
java.awt.* 窗口包
引入包 import + 包名
(对于个人项目的命名，摘自zqxlonely的博文)
indi ：
个体项目，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。
包名为“indi.发起者名.项目名.模块名.……”。
pers ：
个人项目，指个人发起，独自完成，可分享的项目，copyright主要属于个人。
包名为“pers.个人名.项目名.模块名.……”。
priv ：
私有项目，指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。
包名为“priv.个人名.项目名.模块名.……”。
onem ：
与“indi”相同，推荐使用“indi”。
另外，我为了区分团队项目和前面所说项目的区分，还有了一下扩展：
team ：
团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。
包名为“team.团队名.项目名.模块名.……”。
com ：
公司项目，copyright由项目发起的公司所有。
包名为“com.公司名.项目名.模块名.……”。
函数名相同，返回值不同或形参个数或类型或顺序不同，但仅仅返回值不同不构成重载。程序会根据参数列表选择相应函数。
/* * @2016.10.17 * @Ziv * @重载演示 * */ public class overload{ public static void main(String[]args){ over1 over11 = new over1(); System.out.println(over11.getMax(10,11)); System.out.println(over11.getMax(10.1f,11.1f)); System.out.println(over11.getMax(10.22,11.22)); } } class over1{ public int getMax(int a,int b) { if(a>b) { return a; } else { return b; } } public float getMax(float a,float b) //重载 { if(a>b) { return (float)a; } else { return (float)b; } } public double getMax(double a,double b) { if(a>b) { return (double)a; } else { return (double)b; } } }
父类中有的函数，能在子类中重新定义并覆盖，否则则为子类自己的方法
格式： class 类名 extends 父类{}
/* * @2016.10.17 * @Ziv * 继承的演示 */ public class jicheng { public static void main (String []args){ Pupil p1 = new Pupil (); p1.out_();//子类对象调用从父类继承来的函数 } } //抽象学生类，做父类 class Stu{ //父类中的public protected 默认类型的都可被继承 protected int age; protected String name; protected float fee; public void out_(){ System.out.println("aaaaaa"); } } //小学生类 class Pupil extends Stu{ //成员属性 public void pay(float fee){ this.fee = fee; } } //中学生类 class Middle extends Stu{ //计算学费 public void pay(float fee){ this.fee = fee*0.8f; } } //大学生类 class College extends Stu{ //计算学费 public void pay(float fee){ this.fee = fee*0.1f; } }
一种引用（类型）在不同情况下的多种状态：
通过指向父类的指针，来调用在不同子类中的方法，即父类的引用引用子类的实例对象
/* * @2016.10.18 * @Ziv * @多态的程序实例演示 */ public class duotai { public static void main(String[] args) { //多态 Catt cat1 = new Catt(); cat1.cry(); Dogg dog1 = new Dogg(); dog1.cry(); //自动判断an的指向 Anminall an = new Catt(); an.cry(); an = new Dogg(); an.cry(); //创建主人 Host host = new Host(); host.feed(dog1, new food()); host.feed(cat1, new food()); } } //食物类 class food{ String name; public void Showname(){ } } class Fish extends food{ public void Showname(){ System.out.println("Fish"); } } class Bone extends food{ public void Showname(){ System.out.println("Bone"); } } //主人类 class Host{ //喂食，使用多态，方法就可以只用一个 public void feed (Anminall an,food f){ an.eat(); f.Showname(); } } //动物类 class Anminall{ int age;//默认访问权限，可以被同类和同包的访问 String name; public void cry(){ System.out.println("Do not konw"); } //吃东西 public void eat(){ System.out.println("Do not konw"); } } class Catt extends Anminall{ public void cry(){ System.out.println("喵喵"); } //猫吃 public void eat(){ System.out.println("Fish"); } } class Dogg extends Anminall{ public void cry(){ System.out.println("汪汪"); } //狗吃 public void eat(){ System.out.println("Bone"); } }
给出一些没有内容的方法，封装到一起，到某类要使用时，具体写出来
定义接口： interface 接口名
用类实现接口 ：class 类名 implements 接口{方法；变量；}
/* * @2016.10.18 * @Ziv * @接口的实现演示 * */ public class _implements { public static void main(String[] args) { //直接访问接口中的变量 System.out.println(Usb.a); //实例化对象 Phone phone1 = new Phone(); Camera camera1 = new Camera(); Computer com = new Computer(); com.useUsb(camera1); com.useUsb(phone1); //调用接口中的方法 camera1.cc();//camera中实现的是aa中的cc方法 phone1.cc();//Phone中实现的是Usb从aa继承来的cc方法 } } //Usb接口 定义接口，接口中所有方法都不能有主体 interface Usb extends aa{ int a = 1; //声明两个方法 public void start(); public void stop(); } interface aa{ public void cc(); } //编写类，实现USB接口 //当一个类实现了一个接口，要求该类把接口的所有方法都实现 class Camera implements Usb,aa{ //允许一个类实现两个接口 public void start(){ System.out.println("I am a Camera,i will start."); } public void stop(){ System.out.println("I am a Camera,i will stop."); } //另一个接口的实现 public void cc(){ System.out.println("I am interface cc"); } } //编写类，实现USB接口 class Phone implements Usb{ public void start(){ System.out.println("I am a Phone,i will start."); } public void stop(){ System.out.println("I am a Phone,i will stop."); } //实现Usb继承的aa的方法 public void cc(){System.out.println("Usb extends from aa");} } //计算机类 class Computer{ //开始使用usb接口 public void useUsb(Usb usb){ usb.start(); usb.stop(); } } /*接口继承别的接口 interface Tt{ } interface Son extends Tt{ } */
由于父类方法的不确定性 用abstract修饰方法/类
定义：abstract void Son();
只有抽象类中才能定义抽象方法，但抽象类中可以没有抽象方法
抽象类的子类必须实现父类中所有的的抽象方法
抽象类不能实例化对象
/* * @2016.10.18 * @Ziv * @抽象类的必要性演示 * */ public class abstract_class { public static void main (String []args){ Son son = new Son(); son.say(); } } //抽象类 abstract class Father{ int age; String name; //说话 抽象方法 abstract public void say(); } class Son extends Father{ public void say(){ System.out.println("i am Son"); } } class GSon extends Father{ public void say(){ System.out.println("i am GSon"); } }
标签：
原文地址：http://www.cnblogs.com/Harley/p/5982229.html
