Java中面向对象（上）

面向对象的三大特性

1.封装性
2.继承性
3.多态性

类与对象

1.类的定义：

class  Student{
        int  age;                       //类中定义的变量成为成员变量
       void speak(){
           int  age=60;                   //类中定义的变量成为局部变量
 	system.out.println("我今年"+age+岁");
 }
}

Student是类名age是成员变量，speak()是成员方法。在成员方法中可以直接访问成员变量age。
在Java中，定义在类中的变量被称为成员变量。

2.对象的创建与使用：
new关键字创建对象
类名 对象 = new 类名();

Example.java
class  Example01{
public static void main (String[]args){
         Student s1=new Student();            //创建第一个Student对象
		 Student s2=new Student();            //创建第一个Student对象
				s1.age=18;         //为age属性赋值
				s1.speak();       //调用对象方法
				s2.speak();
}
}

3.类的设计

Example02.java
class Example02{
		String name;
		int age;
		public void introduce(){
			system.out.println("大家好，我叫''+name+",我今年"+age+"岁!");
}
}

在Example02类中，定义了两个属性name和age。其中的name属性为String类型，在Java中使用String 类的实例对象表示一个字符串。

4.类的封装

Example03.java
public class Example03{
		public static void main(String[]args){
				Student stu=new Student();
				stu.name="张三";
				stu.age=19;
				stu.introduce();
}
}

类的封装是指在定义一个类时，将类中属性私有化，使用private关键字来修饰，私有属性只能在它所在类中被访问。

Example04.java
class Student{
		private String name;
		private int age;
			//生成相对应的setter和getter方法
			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 void introduce(){
			system.out.println("大家好，我叫"+name+",我今年"+age+"岁了");
			}

public class Example04(){
 public static void main(String[] args) {
				Student stu=new Student();
				stu.setAge(30);
				stu.setName("李四");
				stu.introduce();
}
}
}

构造方法

构造方法的定义
1.方法名与类名相同。
2.在方法名的前面没有返回值类型的声明。
3.在方法中不能使用return语句返回一个值。

Example05.java
class Person{
//下面是构造方法
public Person(){
		system.out.println("无参的构造方法被调用了.........");
}
}
public class Example05(){
			 public static void main(String[] args) {
				Person p=new Person();  //实例化 Person 对象
}

"new Person()"语句的作用除了实例化Person对象，还会调用构造方法Person().

Example06.java
class Person{
		 int  age;
		 public Person(int a){
		 age=a;
 }
		 public void speak(){
		 	System.out.println("I am "+age+" years old.!");
		 }
		}
public class Example06{
		public static void main(String[] args) {
				Person p=new Person(20); //实例化Person对象
				p.speak();
}
}

构造方法的重载

Example07.java
public class Eaxmple07 {
 public static void main(String[] args) {
	Person p1=new Person("张三");
	Person p2=new Person("王五", 19);
	p1.speak();
	p2.speak();
}
}
class Person{
	String name;
	int age;
	
	//定义两个参数的构造方法
	public Person(String con_name,int con_age) {
		name=con_name;
		age=con_age;
	}
	public Person(String con_name) {
		name=con_name;
	}
	public void speak() {
		
		System.out.println("大家好，我叫"+name+",我今年"+age+"岁！");
	}
}

this关键字
this关键字用于方法中访问对象的其他成员
1.通过this关键字可以明确的去访问一个类的成员变量，解决于局部变量名称冲突的问题

class Person{
	int age;
	public Person() {
		this.age=age; 
	}
	public int getAge() {
		return age;
	}
}

2.通过this关键字调用成员方法

class Person{
   public void openMouth() {
	   System.out.println("1223456");
}
   public void speak() {
	   this.openMouth();
}
}

3.构造方法是在实例化对象时被Java虚拟机自动调用的，程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this([参数1，参数2…])”的形式来调用其他的构造方法。

Example08.java
public class Example08 {
 public static void main(String[] args) {
	Person p=new Person("itcast");
	
}
}
class Person{
	
	public Person() {
		System.out.println("无参的构造方法被调用了....");
	}
	public Person(String name) {
		this();   //调用无参的构造方法
		System.out.println("有参的构造方法被调用了.....");
	}

}

static关键字

用于修饰类的成员
1.静态变量
在Java类中，可以使用static关键字来修饰成员变量，该变量被称为静态变量。

Example09.java
public class Example09 {
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student();
		Student.schoolName = "传智播客";
		System.out.println("我的学校是：" + stu1.schoolName);
		System.out.println("我的学校是：" + stu2.schoolName);

	}
}

class Student {
	static String schoolName;

}

2.静态方法
只需要在类中定义的方法前加上static关键字即可

Example10.java
public class Example10 {
	public static void main(String[] args) {
	Person.sayhello();
	}
}

class Person {
	public static void sayhello(){
		System.out.println("hello");
	}

}

3.静态代码块
在Java类中。使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字来修饰的代码块成为静态代码块。

Example11.java
public class Example11{
	//静态代码块
	static {
		System.out.println("测试类的静态代码块执行了");
	}
	public static void main(String[] args) {
		Person  p1 =new Person();
		Person  p2 =new Person();

	}
}
class Person {
	static String country;
	//静态代码块
	static {
		country="china";
		System.out.println("Person类中的静态代码块执行了");
	}

}

内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类。这个内部类所在的类称为外部类。

1.成员内部类

在一个类中除了可以定义成员变量、成员方法、还可以定义类，这样的类被称作成员内部类。在成员内部类中可以访问外部类的所以成员。

Example12.java
public class Example12{
	
	public static void main(String[] args) {
		Outer outer=new Outer();  //创建外部类对象
		outer.test();             //调用test()方法

	}
}

class Outer{
	private int num=4;
	//成员方法访问内部类
	public void test() {
		Inner inner=new Inner();
		inner.show();
	}
	//成员内部类
	class Inner{
		void show() {
			//在成员内部类的方法中访问外部类的成员变量
			System.out.println("num="+num);
		}
	}
}

2.静态内部类

可以使用static关键字来修饰一个成员内部类，该内部类被称为静态内部类，可以在不创建外部类对象的情况下被实例化。

外部类名.内部类名  变量名 = new  外部类名.内部类名();

Example12.java
public class Example12{
	
	public static void main(String[] args) {
		Outer.Inner inner=new Outer.Inner(); //创建外部类对象
		inner.show();             //调用内部的方法

	}
}

class Outer{
	private static int num=6;
	
	//静态内部类
	static class Inner{
		void show() {
			System.out.println("num="+num);
		}
	}
}

3.方法内部类

方法内部类是指在成员中定义的类。它只能在当前方法中被使用。

Example13.java
public class Example13 {
	
	public static void main(String[] args) {
		Outer outer=new Outer();  //创建外部类对象
		outer.test();             //调用test()方法

	}
}

class Outer{
	private int num=6;  //定义成员变量
	//定义内部类
	public void test() {
		class Inner{
			void show() {
				System.out.println("num"+num); //访问外部类的成员变量
			}
		}
		Inner inner=new Inner();  //创建内部类对象
		inner.show();  				//调用内部类的方法
	}

}