1.构造方法Constructor概述和格式(掌握)
A:构造方法概述和作用
给对象的数据(属性)进行初始化
B:构造方法格式特点
a:方法名与类名相同(大小写也要与类名一致)b:没有返回值类型，连void都没有c:没有具体的返回值return;
public class JavaObject { //创建对象JavaObject public static void main(String [] args) {Person p = new Person(); //在一创建对象的时候，系统就帮我们调用了构造方法//p.Person(); //构造方法不能用对象调用p.show();Person p = new Person(); //再次创建对象p.show();}}class Person {private String name; //成员变量都私有private int age;//构造方法public Person() {//System.out.println("hello");//return;//构造方法也是有return语句的；name = "张三";age = 23;}public void show() {System.out.println(name + "..." + age);}}
2.构造方法的重载及注意事项(掌握)
A:案例演示
构造方法的重载重载:在同一类中,方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表有参构造的好处:可以动态的给属性赋值
B:构造方法注意事项
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己手动给出，应自己给出无参构造方法。
public class JavaObject { //创建对象public static void main(String [] args) {Person p1 = new Person();p1.show();System.out.println("-------------------");Person p2 = new Person("张三",23);p2.show();System.out.println("-------------------");Person p3 = new Person("李四",24); //初始化，并动态的赋值p3.show();}}class Person {private String name;private int age;public Person() {System.out.println("空参的构造");}public Person(String name,int age) {this.name = name;this.age = age;System.out.println("有参的构造");}public void show() {System.out.println(name + "..." + age);}}
3.给成员变量赋值的两种方式的区别
A：setXxx()方法—— 修改属性值(开发中用的多一些,因为灵活)B：构造方法—— 给对象中属性进行初始化。public class JavaObject { //创建对象phone public static void main(String [] args) {Person p1 = new Person("张三",23);p1 = new Person("李天一",25); //将元对象变成了垃圾System.out.println(p1.getName() + "..." + p1.getAge());System.out.println("-------------------");Person p2 = new Person(); //空参构造创建对象p2.setName("李四");p2.setAge(24);p2.setName("李鬼")；System.out.println(p2.getName() + "..." + p2.getAge());}}class Person {private String name;private int age;public Person() { //空参构造}public Person(String name,int age) { //有参构造this.name = name;this.age = age;}public void setName(String name) { //设置姓名this.name = name;}public String getName() { //获取姓名return name;}public void setAge(int age) { //设置年龄this.age = age;}public int getAge() { //获取年龄return age;}}
4.学生类的代码及测试(掌握)
A:案例演示 学生类：
成员变量：name，age构造方法：无参，带两个参成员方法： getXxx()/setXxx() java bean类(实体类) show()：输出该类的所有成员变量值
B:给成员变量赋值：
a:setXxx()方法b:构造方法
C:输出成员变量值的方式：
a:通过getXxx()分别获取然后拼接b:通过调用show()方法搞定c:两者区别:
getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
show()只是为了显示属性值
class Student {private String name;private int age;public Student() { //空参构造}public Student(String name,int age) { //有参构造this.name = name;this.age = age;}public void setName(String name) { //设置姓名this.name = name;}public String getName() { //获取姓名return name;}public void setAge(int age) { //设置年龄this.age = age;}public int getAge() { //获取年龄return age;}public void show() {System.out.println("我的姓名是" + name + "我的年龄是" + age);}}public class JavaObject { public static void main(String [] args) {Student s1 = new Student(); //空参构造创建对象s1.setName("李四"); //设置姓名s1.setAge(24); //设置年龄System.out.println("我的姓名是" + s1.getName() + "..." + "我的年龄是" + s1.getAge());System.out.println("-------------------");//getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作Student s2 = new Student("张三",23); //使用有参构造s2.show(); //只是为了显示属性值}}
5.手机类案例(掌握)
成员变量：品牌brand，价格price构造方法：无参有参成员发法：setXxxh和getXxx、showclass Phone {private String brand;private int price;public Phone() { //空参构造}public Phone(String brand,int price) { //有参构造this.brand = brand;this.price = price;}public void setBrand(String brand) { //设置品牌this.brand = brand;}public String getBrand() { //获取拼拍return brand;}public void setPrice(int price) { //设置价格this.price = price;}public int getPrice() { //获取价格return price;}public void show() {System.out.println(brand + "..." + price);}}public class JavaObject { public static void main(String [] args) {Phone s1 = new Phone(); //空参构造创建对象s1.setBrand("小米"); //设置品牌s1.setPrice(2400); //设置价格System.out.println("品牌名称是" + s1.getBrand() + "..." + "价格是" + s1.getPrice());System.out.println("-------------------");//getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作Phone s2 = new Phone("张三",23); //使用有参构造s2.show(); //只是为了显示属性值}}
6.创建一个对象的步骤(掌握)
画图说明一个对象的创建过程(如何加载到内存)做了哪些事情?Student s = new Student();1,Student.class加载进内存2,声明一个Student类型引用s3,在堆内存创建对象,4,给对象中属性默认初始化值5,属性进行显示初始化6,构造方法进栈,对对象中的属性赋值,构造方法弹栈7,将对象的地址值赋值给sclass Student {private String name = "张三";private int age = 23;public Student() { name = "李四";age = 24;}public void show() {System.out.println(name + "..." + age);}}class JavaObject { public static void main(String [] args) {Student s = new Student(); //空参构造创建对象s.show(); //只是为了显示属性值}}
7.长方形案例练习(掌握)
A:案例演示
需求：
定义一个长方形类,定义 求周长和面积的方法，然后定义一个测试类进行测试。
分析
成员变量：宽width，高height，空参有参构造setXxxx和getXxx;求周长getLength()，求面积getArea()
class Rectangle {private int width;private int height;public Rectangle() { //空参构造}public Rectangle(int width,int height) { //有参构造this.width = width;this.height = height;}public void setWidth(int width) { //设置宽this.width = width;}public int setWidth() { //获取宽return width;}public void setheight(int height) { //设置高this.height = height;}public int setheight() { //获取高return height;}public int getLenght() { //获取周长return 2 * (width + height);}public int getArea() { //获取面积return width * height;}}class JavaObject { public static void main(String [] args) {Rectangle s = new Rectangle(10,20); //空参构造创建对象System.out.println(s.getLenght()); //周长System.out.println(s.getArea()); //面积}}
8.员工类案例练习(掌握)
A:案例演示
需求：定义一个员工类Employee
自己分析出几个成员，然后给出成员变量
姓名name,工号id,工资salary
构造方法，
空参和有参的getXxx()setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
work
class Employee {private String name;private String id;//private double salary;//工资public Employee() { //空参构造}public Employee(String name,String id,double salary) { //有参构造this.name = name;this.id = id;this.salary = salary;}public void setName(String name) { //设置姓名this.name = name;}public String setName() { //获取姓名return name;}public void setId(String id) { //设置工号this.id = id;}public String setId() { //获取工号return id;}public void setSalary(double salary) { //设置工资this.salary= salary;}public double setSalary() { //获取工资return salary;}public void work() { //获取信息System.out.println("我的姓名是" + name + "，工号是" + id + "，工资是" + salary);}}class JavaObject { public static void main(String [] args) {Employee e = new Employee("令狐冲","20000",40000); //空参构造创建对象e.work();}}
9.static关键字及内存图(了解)
A:案例演示
通过一个案例引入static关键字。人类：Person。每个人都有国籍，中国。
B:概念
方便在没有创建对象的情况下来进行调用（方法/变量）。static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
class Person {String name;static String country;public void speak() { //说话的方法System.out.println(name + "..." + country);}}class JavaObject { public static void main(String [] args) {Person e = new Person(); //创建对象e.name = "张老师"; //调用姓名属性并赋值e.country = "中国"; //调用国籍属性并赋值e.speak();Person f = new Person(); //创建对象f.name = "李老师"; //调用姓名属性并赋值//f.country = "中国"; //调用国籍属性并赋值f.speak();}}
static关键字的特点(掌握)
A:static关键字的特点
a:随着类的加载而加载b:优先于对象存在
c:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)水杯(不能用静态修饰)共性用静态,特性用非静态
d:可以通过类名调用
其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员
B:案例演示
static关键字的特点
class Person {String name;static String country;public void speak() { //说话的方法System.out.println(name + "..." + country);}}class JavaObject { public static void main(String [] args) {Person.country = "日本"; //静态多了一种调用方式，可以通过类名。System.out.println(Person.country);}}
static的注意事项(掌握)
A:static的注意事项
a:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。
B:案例演示
static的注意事项
class Demo {int num1 = 10; //非静态的成员变量static int num2 = 20;//静态的成员变量//public void print1() { //非静态的成员方法，既可以访问静态的成员也可以访问费静态的成员//System.out.println(num1);//System.out.println(num2);//}public static void print2() { //静态的成员方法System.out.println(num1); //静态的成员方法不能访问费静态的 变量 num1System.out.println(num2);}}class JavaObject { public static void main(String [] args) {// Demo d = new Demo(); //静态多了一种调用方式，可以通过类名。// d.print1();Demo.print2();}}
静态变量和成员变量的区别(掌握)
静态变量也叫类变量 成员变量也叫对象变量A:所属不同
静态变量属于类，所以也称为为类变量成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用成员变量只能通过对 象名调用
main方法的格式详细解释(了解)
A:格式
public static void main(String[] args) {}
B:针对格式的解释
public 被jvm调用，访问权限足够大。static 被jvm调用，不用创建对象，直接类名访问void被jvm调用，不需要给jvm返回值main 一个通用的名称，虽然不是关键字，但是被jvm识别String[] args 以前用于接收键盘录入的
C:演示案例
通过args接收键盘例如数据
class JavaObject { public static void main(String [] args) {/*public:被jvm调用，所以权限要足够大static：被jvm调用，不需要创建对象，直接类名.调用即可void：被jvm调用不需要有任何的返回值。main：只有这样写才能被jvm识别，main不是关键字String [] args:以前是用来接收键盘录入的*/System.out.println(args.length);for (int i = 0;i < args.length ;i ++ ) {System.out.println(args[i])}}}
工具类中使用静态(了解)
A:制作一个工具类
ArrayTool1,获取最大值2,数组的遍历3,数组的反转
加static静态化如果一个类中所有的方法都是静态的，需要多做一步，私有构造方法，private ArrayTool(){}目的是不让其他类创建本类对象,直接用类名调用即可.
//文件ArrayTool.java
class ArrayTool {public static int getMax(int[] arr) {int max = arr[0]; //记录第一个元素for (int i= 1 ;i < arr.length ;i++) {//从第二个元素开始遍历if (max < arr[i]) {//max与数组中其他的元素比较max = arr[i];//记录较大的}}return max;//将最大值返回}public static void print(int[] arr) {for (int i = 0;i < arr.length ; i++ ) { // 遍历数组System.out.print(arr[i] + " ");}}public static void revArray(int[] arr) {for (int i = 0; i < arr.length / 2; i++) { //循环次数是元素个数的一半//arr[0]与arr[arr.length-1-0]交换int temp = arr[i];arr[i] = arr[arr.length-1-i];arr[arr.length-1-i] = temp;}}}
//文件Demo_ArrayTool.java
class Demo_ArrayTool {public static void main(String[] args) {int[] arr = {11,66,22,33,44,55,};/*非静态的调用方法ArrayTool at = new ArrayTool();int max = at.getMax(arr);System.out.println(max);System.out.println("----------------");at.print(arr);System.out.println();System.out.println("----------------");System.out.println("反转后");at.revArray(arr);at.print(arr);*///静态的调用方法ArrayTool.print(arr);}}
说明书的制作过程(了解)
A:对工具类加入文档注释B:通过javadoc命令生成说明书
@author(提取作者内容)@version(提取版本内容)javadoc -d 指定的文件目录 -author -version ArrayTool.java@param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
/**这是一个数组工具类，里面封装了查找数组最大值，打印数组，数组反转方法。@author zhengaidong@version v1.0*/public class JavaObject {/**私有构造方法*/private JavaObject(){}/**这是获取数组中最大值得方法@param arr 接收一个int类型的数组@return 返回数组中的最大值*/public static int getMax(int[] arr) {int max = arr[0]; //记录第一个元素for (int i= 1 ;i < arr.length ;i++) {//从第二个元素开始遍历if (max < arr[i]) {//max与数组中其他的元素比较max = arr[i];//记录较大的}}return max;//将最大值返回}/**这是遍历数组的方法@param arr 接收一个int类型的数组*/public static void print(int[] arr) {for (int i = 0;i < arr.length ; i++ ) { // 遍历数组System.out.print(arr[i] + " ");}}/**这是数组反转的方法@param arr 接收一个int类型的数组*/public static void revArray(int[] arr) {for (int i = 0; i < arr.length / 2; i++) { //循环次数是元素个数的一半//arr[0]与arr[arr.length-1-0]交换int temp = arr[i];arr[i] = arr[arr.length-1-i];arr[arr.length-1-i] = temp;}}}
如何使用JDK提供的帮助文档(了解)
A:找到文档，打开文档B:点击显示，找到索引，出现输入框C:你应该知道你找谁?举例：ScannerD:看这个类的结构(需不需要导包)
成员变量 字段构造方法 构造方法成员方法 方法
学习Math类的随机数功能(了解)
打开JDK提供的帮助文档学习A:Math类概述
类包含用于执行基本数学运算的方法
B:Math类特点
由于Math类在java.lang包下，所以不需要导包。因为它的成员全部是静态的,所以私有了构造方法
C:获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;
public class JavaObject {public static void main(String [] args) {//double d = Math.random();//System.out.println(d);//Math.random()会生成大于等于0.0并且小于1.0的伪随机数for (int i = 0;i < 10;i++ ) {System.out.println(Math.random());}//生成1到100的随机数0.00000000000000-0.999999999999999//Math.random() * 100 ==>0.000000 - 99.9999999999//(int)(Math.random() * 32) ====> 0 - 99//(int)(Math.random() * 100) + 1for (int i = 0;i < 7 ;i++ ) {System.out.println((int)(Math.random() * 32) + 1);}}}
猜数字小游戏案例(了解)
A:案例演示
需求：猜数字小游戏(数据在1-100之间)
import java.util.Scanner;public class JavaObject {public static void main(String [] args) {Scanner sc = new Scanner(System.in);//创建键盘录入对象System.out.println("请输入一个整数，范围在1-100之间");int guessNum = (int)(Math.random() * 100) + 1;//心理想的随机数while (true) {int x = sc.nextInt();if (x > guessNum) {System.out.println("大了");} else if (x < guessNum) {System.out.println("小了");} else {System.out.println("中了");break;}} }}
