面向对象（Object Oriented Programming，OOP）是一种思想，Java可以通过这种思想设计程序。最笨的理解就是让别人去干活，自己做管理。
一. 类：
class Human {
public static void main(String[] args) {
System.out.println("HelloWorld!我是human.");
}
}
在同一个java文件里，我们新建了一个机器（Machine）类，此时的类Machine并不是实实在在的机器，仅仅泛指“机器”这个种类，要想让它干活，还得具体到“对象”，也就是实实在在的机器。
二. 对象：
上面再main方法中，我们根据Machine这个种类，用new创建一个实实在在的machine对象。然后让这个对象运用shout功能，去打印Hello~。
三. 类和对象：
类，是对象的“模板”；对象，是类的实例。类，比如说人；对象，具体的某个人。类，比如说狗；对象，比如说我家的狗狗。我们所在的main方法是程序的Boss，调用其它对象干活，其它对象之间也可以互相调用。main方法所在的类也可以根据需要实例化。
在编程中，我们要根据需要将一些功能集成到一个类中，然后通过调用它的实例来处理数据。当对象产生，OOP就有了封装的概念。
四. 封装：
使用既定的权限关键字修饰，我们可以对类的属性和方法进行隐藏，这里就有了封装的概念。封装显示了Java的安全性。两个对象只能根据权限互相访问调用，而不是随意的。如果你不公开姓名，我就没法知道；我不公开自己的体重，你也不会知道。
public 公开：随意访问。
private 私有：同一个类中可以访问。只能修饰类的属性、方法，或内部类
protected 保护的：同一个包内，以及子类可以访问。只能修饰类的属性、方法，或内部类
default 默认的：同一个包内可以访问。默认没有标注权限修饰符的都是default。
public class PowerTest //我。一个java文件中只能有一个public修饰的类
{
public static void main(String[] args)
{
System.out.println("\t警察抓小偷：\n");
Thief t=new Thief();
t.Steal();
Police police=new Police();
System.out.println("\t直接叫警察，警号："+police.pliceNum);
police.Call();
police.Catch();
police.Drive();
//police.Eta(); //私有的只能在同一个类中访问
Operator operator=new Operator();
System.out.println("\t打话务员报警");
operator.Call();
}
}
class Police //警员
{
public int pliceNum=100010; //警号，公开
private int appetite=3; //饭量，私有
protected int familyMember=3; //家庭成员，受保护的
public void Call(){
System.out.println("我是警察，随时Call我");
}
public void Catch(){
System.out.println("警察抓捕窃贼");
}
private void Eat(){
System.out.println("警察在吃饭");
}
protected void Drive(){
System.out.println("良民可以搭顺风车");
}
}
class Thief
{
private String name="ThreeHand";
private void Eat(){
System.out.println("贼也得吃，自己吃");
}
protected void Steal(){
System.out.println("小偷顺手牵羊");
}
}
class Operator
{
public void Call(){
System.out.println("呼叫110，话务员转警察");
Police p=new Police();
p.Catch();
}
}
五. 抽象：
抽象就是不仔细，没有细节，泛泛的，大体的。如果根据一群人抽象一下“人”这个概念，我们会总结身高、体重、吃饭、哭笑等等方面。身高体重是属性，这个不属于抽象的范围，但吃饭、苦笑是两个功能，属于抽象的范围，每个具体的人根据实际情况来实现吃饭或哭笑。abstract用来修饰抽象的类或方法。
如果出现了抽象方法，那么所在类一定为抽象类；但抽象类中不一定有抽象方法。
当子类没有全部实现抽象类的抽象方法时，须要下一级的子类实现剩余的抽象方法。
抽象类不能用new实例化出对象；须要被继承，并实现其定义的抽象方法。
六. 继承：
extends，继承。也就是遗传自，来源于，属于。如父子相传，小狗属于动物，大楼根据图纸盖得。当然根据封装的概念，如果图纸是保密的，大楼就没法盖。
class Human {
public static void main(String[] args) {
Bus bus=new Bus();
bus.shout();
bus.move();
}
}
abstract class Machine
{
abstract void shout(); //后面没有大括号，没有任何语句
abstract void move();
}
class Bus extends Machine
{
void shout ()
{
System.out.println("嘀嘀！");
}
void move()
{
System.out.println("跑~");
}
}
1. 子类会得到父类所有非私有的属性和方法，
class Human {
public static void main(String[] args) {
Child child = new Child();
child.shout();
System.out.println(child.country);
}
}
class Father
{
String country="中国";
void shout () {
System.out.println("我爱祖国");
}
}
class Child extends Father
{
//继承了父类的属性和方法
}
2. 重写，如果子类中有一个和父类中同名的方法，子类的这个会将父类中的覆盖，
/*
方法覆盖
*/
class Father
{
void shout ()
{
System.out.println("父类中的方法");
}
}
class Child extends Father
{
//重写父类中的同名方法
void shout ()
{
System.out.println("子类中的方法");
}
}
class Human {
public static void main(String[] args) {
Child child = new Child();
child.shout();
}
}
七. 接口：
一个特殊的抽象类，其中所有的方法都是抽象的。所有属性和方法都是public权限。接口的修饰符是interface，要实现接口需要implements。接口也是一系列功能的集合。
和抽象类一样，子类必须全部实现接口的抽象功能，否则子类也是抽象的。
class Human {
public static void main(String[] args) {
Child child = new Child();
child.eat();
child.shout();
System.out.println("Child实例："+child.country);
System.out.println("Child类："+Child.country);
System.out.println("Father类："+Father.country);
}
}
interface Father
{
public static final String country="China";
public void eat();
public void shout();
}
class Child implements Father
{
public void eat(){
System.out.println("Eatfood.");
}
public void shout(){
System.out.println("Letus sing");
}
}
八. 构造方法
任何一个类都有构造方法，就如任何人都有魂儿一样（唯心的说法）。当我们用new创建一个实实在在的人（对象）时，实际是在调用人（类）的灵魂（构造方法）。灵魂是不能被继承的。灵魂可以有很多（精神分裂）。灵魂可能很贪婪。灵魂也是可以沟通的。
/*
方法名与类名相同的无返回值
*/
class Human
{
//穷发飙的魂儿，无参
Human ()
{
System.out.println("我是魂儿");
}
//贪婪的魂儿，须要获取参数
Human(int i)
{
System.out.println("干活收费："+i+"刀");
}
void shout ()
{
System.out.println("我是人类");
}
}
class Structure {
public static void main(String[] args) {
Human h1=new Human();
h1.shout();
Human h2=new Human(10);
h2.shout();
}
这里又多了一个新的概念，重载。有两个构造函数，参数列表不同，两次调用实现了不同的功能。
参数列表中，如果参数数量不同，或参数的数据类型不同，或参数的顺序不同，都会发生重载。重载和构造函数的返回值无关。和参数名无关。
/*
方法名与类名相同的无返回值
*/
class Human
{
//穷发飙的魂儿，无参i
Human (int i)
{
System.out.println("一个整型参数 "+i);
}
//贪婪的魂儿，须要获取参数
Human(int i, int j)
{
System.out.println("两个整型参数 "+i+"，"+j);
}
Human (int i, String s)
{
System.out.println("一个整型参数 "+i+"，一个字符串 "+s);
}
Human (String s, int i)
{
System.out.println("一个字符串 "+s+"，一个整型参数 "+i);
}
}
class Structure {
public static void main(String[] args) {
Human h1=new Human(9);
Human h2=new Human(9,8);
Human h3=new Human(9,"Tom");
Human h4=new Human("Tom",8);
}
}
九. 多态
多种身份，见人说人话，见鬼说鬼话。比如我们有个鬼类，用它来创建了一个实实在在的人，这个人首先继承自鬼，有鬼的面孔，却说着人话。（这个例子很凌乱。）
class Ghost
{
Ghost(){
}
void horror ()
{
System.out.println("鬼吓人！");
}
}
class Human extends Ghost
{
Human(){
}
void horror () //重写
{
System.out.println("人吓人！");
}
}
class Polymorphism
{
public static void main(String[] args)
{
Ghost gh=new Human();
gh.horror();
}
} 
我们无法让这个鬼面人心的家伙变得鬼面鬼心，但可以让它人面人心。修改main函数中的内容，
Ghost gh=newHuman(); //向上转型
gh.horror();
Humang=(Human)gh; //向下转型
g.horror(); 
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
