第6章面向对象基础(6)

重点掌握

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

  for(int j=0;j

  if(studs[j].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+"的速度奔跑");

}

}

转至:↓↓↓

链接:https://www.jianshu.com/p/479baccc460a

来源:

著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

你可能感兴趣的:(第6章面向对象基础(6))