1、面向对象的特点------封装性
/* 封装：隐藏实现细节，对外提供公共的访问方式。 1，安全性。 2，复用性。 3，隔离的变化。后期应用于分层设计。 */ /* 描述人： 属性：姓名，年龄。 行为：说话。 */ class Person { private String name; private/*私有*/ int age; /* 将成员变量私有化，对外提供set get方法，对其访问的原因就是可以属性可控。 私有关键字private 是一个权限修饰符，只能修饰成员(成员变量，成员函数)。 注意：私有仅仅是封装的表现形式之一！ */ public void setName(String s) { name = s; } public String getName() { return name; } public void setAge(int a) { /*可以加入健壮性的判断。 if(a<=0 || a>120) throw */ age = a; } public int getAge() { return age; } void speak() { System.out.println(name+":"+age); } } class PersonDemo { public static void main(String[] args) { Person p = new Person(); // p.name = "旺财"; // p.age = -20; p.setName("旺财"); p.setAge(20); p.speak(); } }
2、this关键字
/* this关键字。 1，区分局部变量和成员变量同名的情况。 用this标识的是成员变量。 this到底是个啥呢？ this其实就代表对象，代表哪个对象呢？ 哪个对象调用了this所在的函数。this就指向哪个对象。 (this就代表着当前这个对象) */ class Person { private String name; private int age; Person() { this.name = "baby"; System.out.println("Person() run..."); } Person(String name) { this.name = name;//局部变量和成员变量重名了。 System.out.println("person(name)...run..."); } Person(String name,int age) { this.name = name; this.age = age; System.out.println("person(n,a)....run...."); } public void show() { System.out.println(this.name+"...."+this.age); } public void method(int x) { this.show(); } } class ThisDemo { public static void main(String[] args) { Person p = new Person("李四"); p.show(); Person p1 = new Person("王武"); p1.method(); } }
/* this关键字的用法二： 构造函数间调用。this关键字。 用法格式：this(对应的实参列表); 注意：必须定义在构造函数的第一行，因为初始化动作要先执行。 构造间调用其实也是为了初始化的复用性。 不要出现互相调用，产生递归，容易栈溢出。 */ class Person { private String name; private int age; Person() { this.name = "baby"; System.out.println("Person() run..."); } Person(String name) { this.name = name; System.out.println("person(name)...run..."); } Person(String name,int age) { this(name);//用于调用构造函数。注意：调用构造函数的语句必须定义在构造函数的第一行！ this.age = age; System.out.println("person(n,a)....run...."); } public void show() { System.out.println(this.name+"...."+this.age); } public void method() { this.show(); } } class ThisDemo2 { public static void main(String[] args) { Person p = new Person("李四",20); new Person(); } }
/* this在代码中的应用。 */ class Person { private int age; Person(int age) { this.age = age; } /* 定义一个功能，判断和别人是否是同龄人。 结果？boolean 参数？Person 功能内部如果用到了调用该功能的对象，用this代表这个对象。 */blic boolean equalsAge(Person p) pu{ return this.age == p.age; } } class ThisDemo3 { public static void main(String[] args) { Person p1 = new Person(32); Person p2 = new Person(23); boolean b = p1.equalsAge(p2); System.out.println("b="+b); } }
3、static关键字
/* static 关键字是一个成员修饰符。 static关键字的特点： 1，静态的数据被对象所共享。 2，它优先于对象加载并存在。 随着类的加载而加载。 3，静态的数据多了一种调用方式：可以直接被类名所调用。 既然静态调用这么方便，是不是可以让所有的成员变量变成静态的呢？ 不行，因为数据中有些是对象共享的数据需要静态化，节省内存空间，严谨。 有些数据是对象特有的数据，这些存储到对象中。 这也是成员变量是否要静态的依据！ 举例：教室里的饮水机和每个对象特有的杯子的故事！ 静态变量和成员变量的区别？ 名称(所属)： 静态变量所属于类，也称为 类变量。 成员变量所属于对象，也称为 实例变量。 内存位置： 静态变量存储于方法区中的静态区中。 成员变量存储于堆内存的对象中。 加载先后： 静态变量随着类的加载而加载，随着类的消失而消失。 成员变量随着对象的加载而加载，随着对象的消失而消失。 */ class Person { String name; static String country = "cn"; } class StaticDemo { public static void main(String[] args) { Person p = new Person(); p.name = "lisi"; //静态的成员的调用。 System.out.println(Person.country); } }
/* 静态方法： 1,静态方法只能访问静态成员，不能直接访问非静态成员。 非静态的方法可以访问静态和非静态。 其实原因就是加载的先后顺序问题。先加载的不能访问后加载。 2,静态方法中不可以出现this，super关键字。 什么时候方法静态？ 方法中如果没有访问对象的特有数据，或者说没有调用过非静态的内容。 该方法就静态化。虽然不静态也可以使用，但是创建调用它的对象没有意义。 */ class Person { String name; static String country = "cn"; static void show() { // System.out.println(this.name);//编译失败。 System.out.println(country); } static void method() { System.out.println(Person.country); } } class StaticDemo2 { public static void main(String[] args) { // new Person().show(); // Person.show(); // new Person().method(); Person.method(); } }
4、main方法
/* public static void main(String[] args) public : 权限修饰符，主方法的权限最大。 static : 随着类的加载而加载，直接被类名调用。 void : 主方法没有具体的返回值。 main : 方法名称，不是关键字，但是该名字固定。 String[] args ： 方法的参数列表，一个字符串数组参数。args就是变量名。 */ class MainDemo { int x = 4; public static void main(String[] args) //args = new String[0]; { /* System.out.println(args.length);//[Ljava.lang.String;@19836ed for(int x=0; x<args.length; x++) { System.out.println(args[x]); } */ new MainDemo().show(); } void show() { System.out.println(x); } }
5、静态代码块
/* 静态代码块。 特点：随着类的加载而执行，而且只执行一次。 作用：用来给类进行初始化的。 */ class StaticCode { // static int x= 3; static { // x = 5; System.out.println("a"); } static void show() { System.out.println("show run"); } } class StaticCodeDemo { static { System.out.println("b"); } public static void main(String[] args) { StaticCode.show(); } static { System.out.println("c"); } }
6、对象的初始化过程
7、小练习
A、
class Person { private String name = "baby"; {//构造代码块作用，给所有的对象初始化。 System.out.println("code......"+this.name); cry(); } Person()//构造函数只给对应的对象初始化。 { // cry(); System.out.println("person() run...."); } Person(String name) { this.name = name; // cry(); System.out.println("person(name) run......"); } void cry() { System.out.println("哇哇......"); } } class CodeDemo { public static void main(String[] args) { Person p = new Person(); Person p1 = new Person("lisi"); {//局部代码块。控制局部变量的生命周期。 int x = 4; System.out.println("x="+x); } System.out.println("x="+x); System.out.println("over"); } }
B、
/* 综合练习，练习一下之前的小知识点。 主函数定义代码--->封装到函数中提高复用性---->将函数封装到对象中。 */ class ArrayToolDemo { public static void main(String[] args) { int[] arr = {34,120,78,45,90,33}; int max = ArrayTool.getMax(arr); int min = ArrayTool.getMin(arr); System.out.println("max="+max); System.out.println("min="+min); } }
C、
/** 这是一个用于操作数组的工具类，功能有获取最值，排序等一系列静态方法。 @author 张三 @version V1.0 */ public class ArrayTool { /** 构造函数。 */ public ArrayTool(){} /** 获取数组的最大值。 @param arr 接收的是一个int类型的数组。 @return 返回该数组的最大值。 */ public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x]>max) max = arr[x]; } return max; } /** 获取数组的最小值。 @param arr 接收的是一个int类型的数组。 @return 返回该数组的最小值。 */ public static int getMin(int[] arr) { int min = arr[0]; for(int x=1; x<arr.length; x++) { if(arr[x]<min) min = arr[x]; } return min; } /** 对整型数组进行从小到大的排序。 @param arr 接收的是一个int类型的数组。 */ public static void selectSort(int[] arr) { for (int x=0; x<arr.length-1 ;x++ ) { for (int y=x+1; y<arr.length ;y++ ) { if(arr[x]>arr[y]) { swap(arr,x,y); } } } } /** 对数组中的两个位置的元素进行置换。 @param arr 接收的是一个int类型的数组。 @param a 需要置换的元素的角标 @param b 需要置换的另一个元素的角标 */ private static void swap(int[] arr,int a,int b) { int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } }