Java OOP 式编程

System.out.println();

public class Main(){
	public static info(String s){//这样就把这句话封装了起来，访问修饰符也可以使用private（不过这种情况经常会和其它方式结合在一起使用的比较多）
	System.out.println(s);
	}
	
	public static void main(String[] args) {
		info("Hello World");
	}

}

public class StudentData {
	private String name;
	private int age;
	private String gender;
	
	//然后按下alt+shift+s，选择Gatters和Settlers，系统会自动生成封装的类
	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 getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;

//还有另一种方式，这里的话， 你就不必再Test类中，一个个的的定义学生的信息参数了
//快捷键同上，找到Constructor using Fileds就可以，但是你要把三个参数的选项都勾上
	public StudentData(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	}
}

public class Test {
	public static void main(String[] args) {
		//这里我把这Test类和StudentData类放在了同一目录下
		StudentData s=new StudentData();//创建我们封装好的类的对象
		s.setAge(18);//这里调用我们封装好的类的方法
		s.setName("Gorit");
		s.setGender("male");
//第二种方式，一步到位	StudentData s=new StudentData("Gorit", 18, "male");//创建我们封装好的类的对象
		
		//这是一种字符串处理方法，把我们想要打印的东西全都存放到str中
		String str="姓名:"+s.getName()+" 性别:"+s.getGender()+" 年龄:"+s.getAge();
		System.out.println(str);
	}
}

public class Father {
	public int money=100;
	
	public void play() {
		System.out.println("踢足球");
	}
}

public class Son extends Father{
	
	public void myMonye(int money) {//这里孩子就继承了父类的属性和方法
//		System.out.println(money);
		System.out.println(super.money);//两种方法均可以调用
	}
	
	public void playBasketball() {//子类另外增加自己的方法
		System.out.println("打篮球");
	}
}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Son s=new Son();//创建子类的对象
			System.out.println(s.money);//孩子继承父亲的money
			s.play();
			s.playBasketball();
	}
}

public class A {
	public int sum(int number1,int number2) {//这是我们写的父类的两数之和的方法
		return number1+number2;
	}
	
	public void poj() {
		System.out.println("我是父类方法1");
	}
}

public class B extends A{
	
	@Override//这个虽然是个注释，但是添加上别人就知道这是重写的方法
	public int sum(int number1,int number2) {
		return number1+number2+1;
	}
	public void poj2() {
		System.out.println("我是子类");
	}
}

package pojo1;

public abstract class Brid {
//	public void attack() {
//		System.out.println("鸟会攻击");
//	}
	public abstract void attack();
	
	public void play() {
		
	}
	//普通方法必须有方法体
	//抽象方法可以没有方法提
}

package pojo1;

public class BoomBird extends Brid{

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("丢炸弹的鸟");
	}

}

package test;

import pojo1.BoomBird;
import pojo1.Brid;

public class BirdTest {
	public static void main(String[] args) {
		Brid b=new BoomBird();
		b.attack();
	} 
}

public interface Call {//这是实现门铃的接口
	//报警
	public void call();

}

public interface Protecte {
	
	//保护的接口
	public void pro();

}

//门
public class Door  implements Protecte,Call {//这里就解决了无法多继承的问题

	@Override
	public void call() {
		// TODO Auto-generated method stub
	}
	@Override
	public void pro() {
		// TODO Auto-generated method stub
	}
}

父类 a=new 子类();

子类 b=(子类)a;