重点掌握
1、类的定义
访问权限控制符
public protected default private
同一个类 可 可 可 可
同一个包 可 可 可
不同包但继承 可 可
全局 可
static 修饰符
如果一个类用static修饰，表示他是静态的
static可以用来修饰类的成员方法、类的成员变量,代码块
一、实体类创建
第一种方式:无参构造+get/set
package com.neuedu.test.chap06;
public class XiYouJi {
//姓名
private String name;
//战斗力
private int sword;
//耐力
private int endurance;
//武器
private String arms;
//年令
private int age;
public XiYouJi() {
super();
System.out.println("无参构造方法被调用");
}
public String getMingzi() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSword() {
return sword;
}
public void setSword(int sword) {
this.sword = sword;
}
public int getEndurance() {
return endurance;
}
public void setEndurance(int endurance) {
this.endurance = endurance;
}
public String getArms() {
return arms;
}
public void setArms(String arms) {
this.arms = arms;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
注意：方法调用：
实例化对象
类名 对象名= new 类名();
public static void main(String[] args) {
//创建对象一般有两种方式
//第一种 清水房+逐步采购 无参构造+各个属性的set方法 =》各个属性的设置
//缺点：逐步构建 代码不够简洁
//优点：修改不会影响原有代码
//适用于属性经常变动的
XiYouJi swk = new XiYouJi();
swk.setName("孙悟空");
swk.setSword(5);
swk.setEndurance(5);
swk.setArms("金箍棒");
swk.setAge(18);
XiYouJi ts = new XiYouJi();
ts.setName("唐僧");
ts.setSword(0);
ts.setEndurance(5);
XiYouJi zbj = new XiYouJi();
zbj.setName("猪八戒");
zbj.setSword(2);
zbj.setEndurance(4);
swk.setArms("耙子");
}
}
构造方法
用来创建对象
特点：1）方法名与类名相同
2）没有返回值 类型，并且没有void占位
3）不需要return
分类：
分为无参构造和有参构造
如果我们实例化对象时如下写：
类名 对象名=new 类名(); 实际调用的是无参构造方法
如果你不写无参构造 ，系统会为你自动生成一个。如果你写了，就会调用你新写的这个。
构造方法的重载
有参构造可以限制参数个数，通过重载实现
有参构造无参构造属于方法重载
学生试验：
把类的无参方法注释掉，看发生什么现象
发现调用无参构造方法的地方报错。
结论：
如果你在类中写了有参构造，那么系统不会再帮你生成无参构造了，你如果还想用无参构造 ，就需要重载一下无参构造方法。
无参构造：
创建方式：右键-source-generate constructor from superclass
public XiYouJi() {
super();
System.out.println("无参构造方法被调用");
}
XiYouJi swk = new XiYouJi();
debug测试一下
学生练习：无参方法创建对象和对象赋值
有参构造：
创建方式：右键-source-generate constructor using fields
系统生成代码如下：
//有参构造-经常用来一次性初始化参数
public XiYouJi(String name, int sword, int endurance, String arms, int age) {
super();
this.name = name;
this.sword = sword;
this.endurance = endurance;
this.arms = arms;
this.age = age;
}
调用方式：
@Test
public void test2() {
//精装房 拎包入住 有参构造 -创建同时把各个属性初始化
//有参构造如何编写
//优点：一次性构建，方便，代码简洁
//缺点：修改麻烦
//适用于属性不经常变动的情况
XiYouJi swk2 = new XiYouJi("孙悟空", 5, 5, "金箍棒",18);
System.out.println(swk2.sword);
}
学生练习：
练习有参方法创建对象和为对象赋值
注意：
一旦编写了有参构造，系统不会再为我们生成无参构造，如果想用无参构造，需要显式编写
其他方法的创建：
除了构造方法外，很多时候我们还需要编写自己的业务方法。这些方法用于做业务。
课堂简单演示：
1）编写一个商品的类，要求包含商品名称和商品价格，并且编写一个方法能够在控制台输出“商品名：价格”。并在主函数中调用
输出示例：
可乐：2.5
鼠标：50
package com.neuedu.test.chap06;
/**
* 1）编写一个商品的类，
* 要求包含商品名称和商品价格，
* 并且编写一个方法能够在控制台输出“商品名：价格”。
* 并在主函数中调用
* @author Administrator
*
*/
public class Product {
//商品名称
private String proName;
//商品价格
private double proPrice;
//编写一个方法能够在控制台输出“商品名：价格”。
public void printDetail(){
System.out.println(this.proName+":"+this.proPrice);
}
public Product(String proName, double proPrice) {
super();
this.proName = proName;
this.proPrice = proPrice;
}
//并在主函数中调用
/*输出示例：
可乐：2.5
鼠标：50*/
public String getProName() {
return proName;
}
public double getProPrice() {
return proPrice;
}
public static void main(String[] args) {
//实例化一个可乐商品
Product keli=new Product("可乐",2.5);
//调用可乐的方法打印可乐的详情
keli.printDetail();
Product mouse=new Product("鼠标",50);
mouse.printDetail();
}
}
上面都演示的无返回值类型的方法，下面学习有返回值类型的方法
课堂练习，作业题2
定义一个矩形类Rectangle：
2.1 有2个属性：长length、宽width
2.2 通过构造方法Rectangle(int width, int length)，分别给两个属性赋值
2.3 定义三个方法：getArea()求面积、getPer()求周长，showAll()分别在控制台输出长、宽、面积、周长。
2.4 创建一个Rectangle对象，并输出相关信息
public class Rectangle {
//长
private double length;
//宽
private double width;
public Rectangle(double length, double width) {
super();
this.length = length;
this.width = width;
}
/**
* getArea()求面积
*/
public double getArea(){
double area=length*width;
return area;
}
/**
* getPer()求周长
*/
public double getPer(){
double girth=(this.length+this.width)*2;
return girth;
}
/**
* showAll()分别在控制台输出长、宽、面积、周长。
*/
public void showAll(){
System.out.println("长"+length);
System.out.println("宽"+width);
double result=getArea();
System.out.println("面积"+result);
double result2=getPer();
System.out.println("周长"+result2);
}
public static void main(String[] args) {
Rectangle rc=new Rectangle(13.4,5);
rc.showAll();
}
}
java 面向对象三大特征：
封装 继承 多态
封装
所谓封装是把对象的属性和行为结合在一个独立的系统单位内部
尽可能隐蔽对象的内部细节，只向外部提供接口
继承（inheritance）：
也称泛化，继承性是子类自动共享父类属性和方法的机制，在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入自己若干新的内容
多态（polymorphism）：
指同一个命名可具有不同的语义
OO方法中，常指在一般类中定义的属性或方法被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为，对于子类，可用不同的方法替代实现父类的服务的方法
static关键字
可以修饰的元素
属性
注意：只能修饰属性，不能修饰局部变量。
方法
代码块
static修饰属性：
所有对象共享，称为静态变量或类变量
不用static修饰的属性称为实例变量
static修饰方法：
不需要实例化，可以直接访问，称为静态方法或类方法
static修饰语句块：
类中由static关键字修饰的，不包含在任何方法体中的代码块，称为静态代码块
*static修饰的属性、方法和代码块的特点
****用static修饰的属性
它们在类被载入时创建，只要类存在，static变量就存在。
静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
直接访问：类名.属性
静态方法
静态方法不需要实例化，可以直接访问，访问方式：
直接访问：类名.方法名()
实例化后访问：对象名.方法名() （不建议使用）
静态语句块
一个类中由static关键字修饰的，不包含在任何方法体中的代码块
当类被载入时，静态代码块被执行，且只被执行一次
静态块经常用来进行类属性的初始化
用static修饰的方法和不用static修饰的方法调用上的区别:
package com.neuedu.test.chap06;
import java.util.UUID;
public class StaticDemo {
//网站访问计数器
//如果要把他变成共享计数器 他的值会动态变化
public static int count;
// 用static修饰的方法是静态方法
public static String uudiUtil() {
// uuid生成器
return UUID.randomUUID().toString();
}
public StaticDemo() {
super();
System.out.println("构造方法被调用");
}
//在类实例化时就调用
//会在所有方法（包括构造方法）执行前被调用
//他适合做一些基本初始化(准备)工作
static{
System.out.println("我先被调用!");
}
public void print(){
System.out.println("print");
}
}
不用static修饰的方法调用是用：
第一步：把类实例化成对象
第二步：调用对象的方法
作业：
本章课后作业
选做题1
1)设计一个类Student，该类包括姓名、学号和成绩。
2)设计一个方法，按照成绩从高到低的顺序输出姓名、学号和成绩信息。
public class Student {
/*
* 1)设计一个类Student，该类包括姓名、学号和成绩。
* 2)设计一个方法，按照成绩从高到低的顺序输出姓名、学号和成绩信息。
*/
private String name;
private int id;
private int score;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int id, int score) {
super();
this.name = name;
this.id = id;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
//把成绩乱序的数组转化成按成绩排序的数组
public void sortByScore(Student[] studs){
for(int i=1;i<studs.length;i++){
for(int j=0;j<studs.length-i;j++){
if(studs[j].getScore()<studs[j+1].getScore()){
Student temp=studs[j];
studs[j]=studs[j+1];
studs[j+1]=temp;
}
}
}
}
public static void main(String[] args) {
Student s1=new Student("顾俊宁",100,84);
Student s2=new Student("李洋",101,94);
Student s3=new Student("王琦舒",102,66);
Student s4=new Student("高荣斌",104,82);
Student s5=new Student("刘元昊",105,98);
//System.out.println("s1---->"+s1);
//把上面四个学生放数组里
Student[] students=new Student[]{s1,s2,s3,s4,s5};
Student s=new Student();
s.sortByScore(students);
for(Student stu:students){
System.out.println(stu.getName());
System.out.println(stu.getScore());
System.out.println("----------->");
}
}
}
选做题
2、定义一个汽车类Vehicle，要求如下：[选做题]
2.1属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型），并且所有属性为私有。
2.2至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。
2.3为私有属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。
2.4定义一个一般方法run()，用打印语句描述汽车奔跑的功能
2.5定义测试类VehicleTest，在其main方法中创建一个品牌为“benz”、颜色为“black”的汽车。
package com.neuedu.chap06.homework;
public class Vehicle {
private String brand;
private String color;
private double speed=0;
public Vehicle(String brand, String color) {
super();
this.brand = brand;
this.color = color;
this.speed = 0;
}
public String getBrand() {
return brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
public static void main(String[] args) {
Vehicle y=new Vehicle("benz","black");
y.run();
}
public void run(){
System.out.println("颜色为："+color+brand+"以"+speed+"的速度奔跑");
}
}
