java oop

 /**
 多层嵌套内部类, 调用时要层层往下调用
 格式：
 外部类.内部类1.内部类2 对象名 = new 外部类().new 内部类1().new 内部类2();
 对象名.属性/方法名();
 */
class Outer
{
	public void oSay()
	{
		System.out.println("这是 outer 方法");
	}
	public class Inter1
	{
		public void iSay()
		{
			System.out.println("这是 inter1 方法");
		}
		public class Inter2
		{
			public void say()
			{
				System.out.println("这是 inter2 的 say method");
			}
		}
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer.Inter1.Inter2 oii = new Outer().new Inter1().new Inter2();
		oii.say();
	}
}
// =============
/**
实例内部类 Inter与外部类 Outer有着同名的成员变量i,则在内部类 Inter中,
i,this.i和 Inter.this.i都表示为 Inter类的成员i;而 Outer.this.i才表示外部类 Outer
的成员
*/
class Outer
{
	int i = 10;
	public class Inter
	{
		int i = 20;
		public void getOuterI()
		{
			System.out.println("i表示为 Inter中的 i 值: "+i); // 20
			System.out.println("this.i表示为 Inter中的 i 值；"+this.i); // 20
			System.out.println("Inter.this.i表示为 Inter 中 i 的值："+Inter.this.i); // 20
			System.out.println("Outer.this.i表示为 Outer中的 i 值："+Outer.this.i); // 10
		}
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer.Inter oi = new Outer().new Inter();
		oi.getOuterI();
	}
}
// =============
/**
静态内部类创建对象实例
外部类.静态内部类 静态内部类对象 = new 外部类.静态内部类();
*/
class Outer
{
	private int a = 4; // 定义实例属性 a
	private static int b = 5; // 定义静态属性 b
	public static class Inter  // 定义静态内部类
	{
		private int x = 100;		// 定义实例属性 x
		private static int y = 200;  // 定义静态属性 y
		public void add()					// 定义实例方法
		{
			// 通过外部类的实例对象调用外部类的非静态成员
			int temp = new Outer().a;
			System.out.println(temp+"+"+x+"="+(x+temp));
		}
		public static void mul() // 定义静态方法
		{
			// 直接调用外部类的静态成员
			System.out.println(b+"+"+y+"="+(b+y));
		}
	}
	public void getInfo()
	{
		// 通过内部类对象访问静态内部类的非静态方法
		new Inter().add();
		// 直接通过"静态内部类.静态方法"形式访问静态内部类的静态方法
		Inter.mul();
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer out = new Outer(); // 创建外部类实例
		out.getInfo();
		Outer.Inter in = new Outer.Inter(); // 创建内部类实例
		in.add();
		in.mul();
	}
}
/*
4+100=104
5+200=205
4+100=104
5+200=205
*/
// =============
/*
局部内部类：
是指定义在方法体内的内部类，局部内部类仅在该方法里有效，因此，
局部内部类不能被外部类和外部类以外的其它类访问，所以局部内部类
不需要访问控制符和 static 修饰符的
*/
class Outer
{
	public void fun()
	{
		class Inter
		{
			public int i = 90;
		}
		Inter in = new Inter();
		System.out.println(in.i);
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer out = new Outer();
		out.fun();
	}
}
// =============
/*
局部内部类：
是指定义在方法体内的内部类，局部内部类仅在该方法里有效，因此，
局部内部类不能被外部类和外部类以外的其它类访问，所以局部内部类
不需要访问控制符和 static 修饰符的
*/
class Outer
{
	public void fun()
	{
		class Inter				// 定义局部内部类
		{
			public int i = 90;
		}
		Inter in = new Inter(); // 创建局部内部类的实例
		System.out.println(in.i);
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer out = new Outer(); // 创建外部类实例
		out.fun();
	}
}
// ============
/*
局部内部类可以访问外部类的所有成员，包括私有成员。
若局部内部类定义在静态方法体内时，局部内部类不能直接访问外部类的非静态成员，
但是可以访问外部类的静态成员。若需要调用外部类的非静态成员时，
可以通过外部类的实例。
*/
class Outer
{
	private float f = 1.0F; //实例属性
	private static int x = 90; // 静态属性
	public void fun1()	// 实例方法
	{
		class Inter1		// 定义局部内部类
		{
			private float interF = 4.0F;
			public Inter1()  // 构造方法
			{
				System.out.println(f+"+"+interF+"="+(f+interF));
			}
		}
		new Inter1();  //匿名对象
	}

	public static void fun2()		// 静态方法
	{
		class Inter2
		{
			private int i = 10;
			public Inter2()
			{
				System.out.println(i+"+"+x+"="+(i+x));
				float temp = new Outer().f;
				System.out.println(i+"+"+temp+"="+(i+temp));
			}
		}
		new Inter2();
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer out = new Outer();
		out.fun1();
		out.fun2();
	}
}
// ==========
/*
匿名内部类是指在定义时没有名称的内部类，必须在声明时候时使用 new 主义声明类.
匿名内部类是一种特殊的内部类，除了具有普通内部类的特点以外，还有自己的一些特点。
匿名内部类一般只使用一次
格式：
new <类/接口>([参数列表]){
	......
}
虽然匿名内部类没有类名，匿名内部类必须扩展一个基类或实现一个接口，但不要显式地
使用 extends 或 implements 关键字。如果匿名内部类继承抽象类或实现接口时，还要实现
父类及接口中所有的抽象方法。
*/
// 以下的匿名内部类继承了抽象类
abstract class AbstractClass  // 定义抽象类
{
	public abstract void getInfo(); // 声明抽象方法
}
class Inter
{
	public void print()
	{
		show(new AbstractClass(){  // 匿名内部类
			public void getInfo()
			{
				System.out.println("Hi,lin3615");
			}
		});
	}
	public void show(AbstractClass a) // 传入抽象类实例
	{
		a.getInfo();			// 调用抽象类方法
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		new Inter().print(); // 创建 Inter类的实例并调用 print方法
	}
}
// ============
//定义类
访问控制符 [修饰符] class 类名
{
	访问控制符 [修饰符] 数据类型 属性名;
	.....;
	访问控制符 [修饰符] 数据类型 方法名(参数列表)
	{

	}
}
访问控制符：主要有 默认控制符（无关键词）,public
修饰符: static final abstract ...

// 创建对象
// 格式1
类名 对象名=null;
对象名 = new 类名();

// 格式2
类名 对象名 = new 类名();

class Person
{
	String name;
	int age;
	public void say()
	{
		System.out.println("my name is "+name+",age is "+age);
	}
}

public class Hi
{
	public static void main(String[] args)
	{
		Person p1 = null;
		p1 = new Person();

		Person p2 = new Person();
		Person p3 = p2;

		p1.name="小二";
		p1.age = 26;
		p1.say(); // 输出

	}
}
// =================
// -------------
class Person
{
	private String name;
	private int age;
	public void setName(String nn)
	{
		this.name = nn;
	}
	public void setAge(int aa)
	{
		this.age = aa;
	}
	public void say()
	{
		System.out.println("my name is "+name+",age is "+age);
	}
}

public class Hi
{
	public static void main(String[] args)
	{
		Person p1 = null;
		p1 = new Person();
		p1.setName("lin3615");
		p1.setAge(26);
		p1.say();

	}
}
// ====================

匿名对象:指没有栈空间的对象，即没有没有明显给出名字的对象。
匿名对象使用的是堆内存，是通过关键词new进行开辟的,只能使用一次
class Person
{
	private String name;
	private int age;
	public  Person(String s, int a)
	{
		this.name =s;
		this.age = a;
	}
	public void setName(String nn)
	{
		this.name = nn;
	}
	public void setAge(int aa)
	{
		this.age = aa;
	}
	public void say()
	{
		System.out.println("my name is "+name+",age is "+age);
	}
}

public class Hi
{
	public static void main(String[] args)
	{
		Person p1 = new Person("lin", 26);
		p1.say();
	}
}

// 构造函数,也可重载，如果没有显示声明，则调用系统默认的，（是一个的无参方法）
构造方法与类名一致
不能有任何返回值的类型声明,包括 void
不能使用return
不能被static,final,abstract,native和synchronized 修饰
// 创建构造方法：
格式1:
访问控制符 类名()
{
	//
}

格式2:
访问控制符 类名(参数列表)
{
	//
}

// static 静态，java不没有传统意义上的全局，所以可用此表示全局
public class Hi
{
	public static int ticket = 10; //定义静态变量
	public void sell()	// 定义sell()方法
	{
		ticket--;
		System.out.println("剩下 "+ticket);
	}
	public static void left()  // 定义静态方法 left()
	{
		int i = ticket-2;
		System.out.println("还剩下："+i);
	}
	public static void main(String[] args)
	{
		int x = ticket--;   // 直接访问 ticket
		System.out.println("x = "+x+", ticket = "+ticket);
		int y = Hi.ticket--;  // 通过类名访问
		System.out.println("y = "+y+" ticket = "+ticket);
		Hi str = new Hi();
		str.left();				// 通过非静态访问
		int k = str.ticket--;		// 通过实例访问
		System.out.println("k = "+k+", ticket = "+ticket);
		System.out.println(Hi.ticket);	// 通过类访问
		left();									// 通过静态访问
		Hi.left();							// 通过非静态访问
	}
}
/*
x = 10, ticket = 9
y = 9 ticket = 8
还剩下：6
k = 8, ticket = 7
7
还剩下：5
还剩下：5
*/
// ========================
public class Hi
{
	{				// begin 构造块
		System.out.println("构造块1");
	}				// end 构造块

	{		// begin 构造块
		System.out.println("构造块2");
	}	// end 构造块
	public Hi()
	{
		System.out.println("构造方法");
	}
	public static void main(String[] args)
	{
		new Hi();
		new Hi();
		new Hi();
	}
}
/*
构造块1
构造块2
构造方法
构造块1
构造块2
构造方法
构造块1
构造块2
构造方法
*/
//====================
// 静态代码块只会执行一次
class Code
{
	{
		System.out.println("code的构造块");  // 构造代码块  4
	}
	static
	{
		System.out.println("code 的静态代码块");  // 静态代码块  3
	}

	public Code()
	{
		System.out.println("code 的构造方法普通代码块"); // 构造方法
	}
}
public class Hi
{
	{
		System.out.println("Hi 的构造块");  // 构造代码块
	}
	static
	{
		System.out.println("Hi 的静态代码块");  // 静态代码块   1
	}

	public Hi()
	{
		System.out.println("hi 的构造方法普通块");  // 构造方法
	}
	public static void main(String[] args)
	{
		System.out.println("Hi 的主体方法");  //2
		new Code();
		new Code();
		new Hi();
		new Hi();
	}
}
/** 静态代码块只会执行一次，无论在一次中，实例多少都是一次
Hi 的静态代码块
Hi 的主体方法
code 的静态代码块
code的构造块
code 的构造方法普通代码块
code的构造块
code 的构造方法普通代码块
Hi 的构造块
hi 的构造方法普通块
Hi 的构造块
hi 的构造方法普通块
*/
// ============

// 使用 package 定义包
// 定义包就是将声明的类放入包中，为包指定包名,格式如下：
// package 包名1[.子包名1.子包名2....];
package org.com.pack;
public class Hi
{
	public static void main(String[] args)
	{
		System.out.println("定义包");
	}
}

// package 语句必须是程序中可执行的第一行代码
// package 语句只能有一句
// 在前面的包名是 后面的包名 的父目录
// 没有 package 语句，则默认无包名
// 用javac 编译,编译如下:
// javac -d . Hi.java
// -d 表示生成目录. . 表示目录的位置，此表示生成为当前目录，最终会生成 org/com/pack/Hi.class
// 执行时用 java 包路径.类名: java org.com.pack.Hi

// 当定义包后，同一个包中的类是默认导入的，如果一个类访问来自另一个包中的类时,
// 前者必须通过 import 语句把 后者导入才能使用。
// import 语法格式
// 格式1：import 包名[.子包名...].类名;  只会导入当前的类
// 格式2: import 包名[.子包名 ...].*; 会导入包中所有的类，但不会导入其子包中的类，要用到时还得手动导入
// ===================

// 建立 Student.java, Student.class 位于 org.com.pack.stu中
package org.com.pack.stu;
public class Student
{
	private String name;
	private int age;
	public Student()
	{

	}

	public Student(String name, int age)
	{
		setName(name);
		setAge(age);
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public String getName()
	{
		return this.name;
	}
	public int getAge()
	{
		return this.age;
	}
	public void show()
	{
		System.out.println("my name is "+this.name+" and age is "+this.age);
	}
}

// 建立 Hi.java, 生成的类位于包 org.com.pack.pack中
package org.com.pack.pack;
import org.com.pack.stu.Student;
public class Hi
{
	public static void main(String[] args)
	{
		Student stu = new Student("lin3615", 26);
		stu.show();
	}
}
// javac -d . 文件1.java 文件2.java ...可以连接多个一起编译
// javac -d . Student.java Hi.java
// java org.com.pack.pack.Hi
// =====================
// 静态导入
// Student.java
package org.com.pack.area;
public class Student
{
	public static double PI = 3.14;
	public static double round(int r)
	{
		return PI*r*r;
	}
	public static int square(int a)
	{
		return a*a;
	}
}

// Hi.java
package org.com.pack.pack;
import static org.com.pack.area.Student.*;
public class Hi
{
	public static void main(String[] args)
	{
		System.out.println("PI = "+PI);
		System.out.println("ROUND = "+round(10));
		System.out.println("square = "+square(10));
	}
}
// javac -d . Student.java Hi.java
// java org.com.pack.pack.Hi

// 手动装箱/拆箱
public class Hi
{
	public static void main(String[] args)
	{
		int x = 100;
		Integer in = new Integer(x); // 手动装箱
		System.out.println(in);
		Float f = new Float(3.14F);
		float y = f.floatValue();   // 手动拆箱
		System.out.println(y);
	}
}
// ===================
// -----------
public class Hi
{
	public static void main(String[] args)
	{
		int x = 100;
		Integer in = x;	// 自动装箱
		System.out.println(in);
		Float f = 10.98F;
		float y = f;  // 自动拆箱
		System.out.println(f);
	}
}

// 转换成字符串，用封装中的 toString() 方法
public class Hi
{
	public static void main(String[] args)
	{
		int x = 100;
		Integer in = new Integer(x);
		String ii = in.toString();
		Float f = new Float(10.90F);
		String ff = f.toString();
		Double d = new Double(89.76D);
		String dd = d.toString();
		System.out.println(ii+","+ff+","+dd);
	}
}
// ================
// 字符转为数值 parseXxx(string str)/ parseXxx(String str, int i),其中 Xxx: Int,Double ...
public class Hi
{
	public static void main(String[] args)
	{
		String ii = "333";
		String dd = "1.99";
		int i = Integer.parseInt(ii);  // 字符串转为整型
		double d = Double.parseDouble(dd);  // 字符串转为浮点
		System.out.println(i*d);
	}
}
// ===================

// --------------
// final 变量，属性，引用,其中引用的属性可以改变
public class Hi
{
	final float PI = 3.14f;
	final int arrInt[] = {1,2,3,4};
	final int num;
	final String str;
	{
		num = 100;
	}

	public Hi()
	{
		str = "lin3615";
	}
	public static void main(String[] args)
	{
		final char c = 'A';
		Hi p = new Hi();
		System.out.println("c = "+c);
		System.out.println("PI = "+p.PI);
		System.out.println("num = "+p.num);
		System.out.println("Str = "+p.str);
		for(int i=0; i<4; i++)
		{
			System.out.print(p.arrInt[i]+" ");
		}
		System.out.println();
		for(int j = 0; j< 4; j++)
		{
			p.arrInt[j] = p.arrInt[j] * 10;
		}
		for(int j = 0; j< 4; j++)
		{
			System.out.print(p.arrInt[j]+" ");
		}
	}

}
// ================
// ------------
// final 方法不可继承，但可重写
class Base
{
	public final void add(int x, int y)
	{
		System.out.println("x+y = "+(x+y));
	}
}
class Sub extends Base
{
	public final void add(int x, int y, int z)
	{
		System.out.println("x+y+z = "+(x+y+z));
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Sub sub = new Sub();
		sub.add(1,2);
		sub.add(1,2,3);
	}
}

// ==============
// 如果子类没有继承父类的抽象方法，则报错
abstract class Person
{
	public static final String contry = "China";
	private String name;
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
	public abstract void tell();
	// public abstract void say();
}
class Student extends Person
{
	public void tell()
	{
		System.out.println("my name "+this.getName()+", and "+this.contry);
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Student stu = new Student();
		stu.setName("lin3615");
		stu.tell();
	}
}
// =============
// 调用抽象类中的构造方法,隐含 super();
abstract class Person
{
	public Person()
	{
		System.out.println("这是父类的构造方法");
	}
}
class Student extends Person
{
	public Student()
	{
		System.out.println("这是 student 方法");
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Student stu = new Student();
	}
}
// 这是父类的构造方法
// 这是 student 方法

// ==============
// 显示用 supper()
abstract class Shape
{
	private float width;
	private float high;
	public Shape()
	{

	}
	public Shape(float width, float high)
	{
		this.width = width;
		this.high = high;
	}
	public void setWidth(float width)
	{
		this.width = width;
	}

	public float getWidth()
	{
		return this.width;
	}

	public void setHigh(float high)
	{
		this.high = high;
	}
	public float getHigh()
	{
		return this.high;
	}
	public abstract void area();
	public abstract void cir();
}
class Rectangle extends Shape
{
	public Rectangle()
	{

	}
	public Rectangle(float width, float high)
	{
		super(width, high);
	}
	public void area()
	{
		System.out.println(this.getWidth() * this.getHigh());
	}
	public void cir()
	{
		System.out.println(this.getWidth() * this.getWidth());
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Rectangle rec = new Rectangle(1.8f,2.1f);
		rec.area();
		rec.cir();
	}
}
// -============

// 接口
/**
 格式
 [public] interface 接口名称 [extends 父接口1,父接口2,..]
 {
	 [public static final ] 数据类型 变量名 = 初值; // 默认就是 public static final
	 [public abstract] [native ] 返回类型 方法体([参数列表]); // 默认就是 public abstract
}
*/
interface InterShape
{
	public static final float PI = 3.14F;
	public abstract void getArea();
	public abstract void getCir();
}
class Round implements InterShape
{
	private float radius;
	public Round()
	{

	}
	public Round(float radius)
	{
		this.radius = radius;
	}
	public void setRound(float radius)
	{
		this.radius = radius;
	}
	public float getRound()
	{
		return this.radius;
	}
	public void getArea()
	{
		System.out.println(this.getRound() * InterShape.PI);
	}
	public void getCir()
	{

	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Round rr = new Round(3.9F);
		rr.getArea();
	}
}
// ===============

// 抽象类实现接口
interface InterShape
{
	public static final float PI = 3.14f;
	public abstract void getArea();
	public abstract void getCir();
}
abstract class Sphere implements InterShape
{
	public abstract void getVolume();
}
class Round extends Sphere
{
	private float radius;
	public Round()
	{

	}
	public float getRadius()
	{
		return this.radius;
	}
	public Round(float radius)
	{
		this.radius = radius;
	}
	public void getArea()
	{
		System.out.println(InterShape.PI*this.getRadius());
	}
	public void getCir()
	{
		System.out.println(InterShape.PI+this.getRadius());
	}

	public void getVolume()
	{
		System.out.println(InterShape.PI-this.getRadius());
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Round rr = new Round(10.88f);
		rr.getArea();
	}
}
// ================

// 接口多重继承
// [public] interface 子接口 extends 父接口A[,父接口B....]{}
interface Ok
{
	public static final float PI = 3.14f;
}
interface InterShape
{
	public abstract void getArea();
}
interface InterTwo extends Ok,InterShape
{
		public abstract void getCir();
}
abstract class Sphere implements InterTwo
{
	public abstract void getVolume();
}
class Round extends Sphere
{
	private float radius;
	public Round()
	{

	}
	public float getRadius()
	{
		return this.radius;
	}
	public Round(float radius)
	{
		this.radius = radius;
	}
	public void getArea()
	{
		System.out.println(InterTwo.PI*this.getRadius());
	}
	public void getCir()
	{
		System.out.println(InterTwo.PI+this.getRadius());
	}

	public void getVolume()
	{
		System.out.println(InterTwo.PI-this.getRadius());
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Round rr = new Round(10.88f);
		rr.getArea();
	}
}
// ============
// 对象数组
// 类名 对象数组名[]  = new 类名[数组长度]
// 动态初始化
class School
{
	private String name;
	public School(){}
	public School(String name)
	{
		setName(name);
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		School school[] = new School[4];
		school[0] = new School("一加大学");
		school[1] = new School("二个大学");
		school[2] = new School("三个大学");
		school[3] = new School("aaaaa");
		for(School a:school)
		{
			System.out.print(a.getName()+" ");
		}
	}
}
// ================
// 静态初始化
class School
{
	private String name;
	public School(){}
	public School(String name)
	{
		setName(name);
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		School school[] = {new School("aa"), new School("bbb"), new School("cccc")};
		for(School aa:school)
		{
			System.out.print(aa.getName()+" ");
		}
	}
}
// ===================
// 内部类
/*
[public ] class 外部类名
{
	[访问控制符] [修饰符]  成员;
	...
	[访问控制符] [修饰符] class 内部类
	{
		[访问控制符] [修饰符] 成员;
	}
}
*/
// 定义内部类
class Outer
{
	private String str = "lin3615";
	public class Inter
	{
		public void add(int x, int y)
		{
			System.out.println("x+y = "+(x+y));
		}
		public void getStr()
		{
			System.out.println(str);
		}
	}
	public void getInfo()
	{
		new Inter().getStr();
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Outer out = new Outer();
		out.getInfo();
		Outer.Inter oin = new Outer().new Inter();
		oin.add(3,5);
		oin.getStr();
	}
}
// =================
　　
// ==========
/*
直接使用 new Inter() 为接口实例化，但接口本身是不能实例化的，
所以在 new Inter() 之后的花括号 {} 中写的就是实现接口中的抽象方法
*/
interface Inter				// 定义接口
{
	public abstract void getInfo();  // 声明抽象方法
}
class InterClass			// 定义类
{
	public void print()
	{
		show(new Inter(){		// 匿名内部类
			public void getInfo()
			{
				System.out.println("这是匿名内部类实现接口");
			}
		});
	}
	public void show(Inter i)  // 传入接口
	{
		i.getInfo();						// 调用抽象类方法
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		new InterClass().print(); // 创建 InterClass 类的实例并调用print()方法
	}
}
// =============