this关键字
定义学生类,
姓名,年龄
学习.
还需要使用测试类进行测试StudentTest
在当前的公共访问方法中,(setXXX())中给成员变量进行赋值,变量n,a...都不标识符的规则(见名知意!)
Java中规定,在书写一个标准类的时候,为了防止成员变量名称和局部变量名称一致,提供了一个关键字:this
局部变量会隐藏成员变量
this:为了局部变量和成员变量 ,this代表当前该对象的地址值引用!
*/
class Student{
private String name
;
private int 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 study(){
System
.out
.println("Good Good Study,Day Day Up...");
}
public void show(){
System
.out
.println(this.name
+"----"+this.age
) ;
}
}
class StudentTest{
public static void main(String
[] args
){
Student s
= new Student() ;
s
.setName("马伊琍") ;
s
.setAge(30);
System
.out
.println(s
.getName()+"---"+s
.getAge()) ;
s
.show() ;
}
}
构造方法：
对于成员变量的赋值有几种方式: 1)setXXX()公共访问方法 2)构造方法进行赋值 构造方法:(属于一个类的成员) 1)没有具体的返回值类型 2)连void都没有 3)方法名和类名相同 作用:就是给当前类进行数据初始化! 构造方法的目的: 为了给当前类的成员进行数据初始化! 构造方法:如果标准类的时候,没有给出构造方法,系统默认会提供无参构造方法 注意:如果提供了有参构造方法,系统不会再提供无参构造方法.(永远给出无参构造方法…) 构造方法是可以重载的!
//定义一个Teacher类
class Teacher{
private String name ; //姓名 null
private int age ; //年龄 0
//无参构造方法
public Teacher(){
System.out.println("我给了,你还给吗?") ; //初始化无参构造
}
//带一个参数的构造方法
public Teacher(String name){
System.out.println("这是带String参的有参构造方法...") ;
this.name = name ;
}
//带一个int类型参数的构造方法
public Teacher(int age){
System.out.println("这是带int类型参数的有参构造...") ;
this.age = age ;
}
//带多个参数的构造方法
public Teacher(String name,int age){
System.out.println("这是带多个参数的有参构造方法...") ;
this.name = name ;
this.age = age ;
}
//输出成员变量
public void show(){
System.out.println(name +"----"+age) ;
}
}
//测试类
class ConstructorDemo2{
public static void main(String[] args){
//创建Teacher对象
Teacher t = new Teacher() ;
t.show() ;
System.out.println("------------------");
//创建Teacher
Teacher t2 = new Teacher("高圆圆") ;
t2.show() ;
System.out.println("------------------");
Teacher t3 = new Teacher("高圆圆",27) ;
t3.show() ;
System.out.println("------------------");
Teacher t4 = new Teacher(27) ;
t4.show() ;
}
}
类的成员:
1)成员变量
2)构造方法
3)成员方法**
标准类的最终版写法
学生类
成员变量:姓名,年龄
构造方法:无参,有参
成员方法:setXXX()/getXXX()
study()
手机类:
品牌,颜色.价格
构造方法:无参/有参
//学生类
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 study(){
System.out.println("学习Java...") ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//方式1:无参构造方法+setXXX()
Student s = new Student() ;
s.setName("高圆圆") ;
s.setAge(27) ;
s.study();
System.out.println(s.getName() +"---"+s.getAge()) ;
System.out.println("---------------------");
//方式2:通过有参构造进行赋值
Student s2 = new Student("赵又廷",29) ;
System.out.println(s2.getName() +"---"+s2.getAge()) ;
s2.study();
}
}
成员方法
有返回值类型的方法
1)带形式参数的
2)无参
没有具体返回值类型的方法:void
1)带形参的
2)无参
class Student{
private String name ;
private int age ;
//无返回值,无参
public void show(){
System.out.println("无返回值无参的成员方法...") ;
}
public void function(String s){
System.out.println("world"+s) ;
}
//有返回值类型,无参的
public String method(){
return "helloworld" ;
}
//有具体返回值类型的并且带参数的成员方法
public String method2(int a){
return "javaEE"+a;
}
}
//测试类
class Test{
public static void main(String[] args){
//通过对象调用当前Student类中的成员方法
Student student = new Student() ;
student.show();
student.function("java") ;
String s = student.method();
System.out.println(s) ;
String s2 = student.method2(10) ;
System.out.println(s2) ;
}
}
static关键字
定义一个 人类:Person
name,age,country(国籍)
定义PersonTest类,进行测试
以下代码,给成员变量赋值,成员变量country（都是中国）都是相同的,就会在内存中消耗内存空间的. 针对这种多个对象共有一个成员变量,Java提供了一个关键字: static 静态(共享,共用) static修饰成员变量,成员方法
class Person{
String name ;
int age ;
//String country ;
static String country ; //被Person类的多个对象共用!
//无参构造方法(永远给出)
public Person(){}
//带两个name,age的有参构造
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
//三个参数的
public Person(String name ,int age,String country){
this.name = name ;
this.age = age ;
this.country = country ;
}
//show(),显示成员变量
public void show(){
System.out.println("姓名是:"+name+"的人,年龄是:"+age+",国籍是:"+country) ;
}
}
//测试类
class PersonTest{
public static void main(String[] args){
//创建第一个Person类对象
Person p1 = new Person("西施",28,"中国") ;
p1.show() ;
System.out.println("-------------------");
//创建第二个对象
//Person p2 = new Person("貂蝉",20,"中国") ;
Person p2 = new Person("貂蝉",20) ;
p2.show() ;
System.out.println("-------------------");
//Person p3 = new Person("王昭君",29,"中国") ;
Person p3 = new Person("王昭君",29) ;
p3.show() ;
System.out.println("-------------------");
p3.country = "美国" ;
p3.show() ;
p1.show() ;
p2.show() ;
}
}
main方法解释
main方法的解释:
public static void main(String[] args): jvm识别的程序的入口
public :权限修饰符,公共的,公开的,保证访问权限足够大
static:静态修饰,和类有关系,优先对象存在
void:由jvm调用,没有具体的返回值类型 ,使用void代替
main:方法名, 编程语言,大部分都是有一个程序的入口,Java叫main(主方法)
String[] args: 接收字符串数组,参数名args,
Jdk 1.0版本
早期接收键盘录入数据的.
java 类名 数据1 数据2 数据3....
args[0]
args[1]
args[2]
Jdk:1.5以后,可以使用Scanner(System.in) ;
高级录入:
BufferedReader:字符输入流
class MainDemo{
public static void main(String[] args){
//输出args
//System.out.println(args) ; //[Ljava.lang.String;@6d06d69c
//System.out.println(args[0]) ; //ava.lang.ArrayIndexOutOfBoundsException :数组角标越界异常
//int[] arr = {元素1,元素2,元素3....} ;
args = new String[3];
args[0] = "hello" ;
args[1] = "world" ;
args[2] = "java" ;
//遍历数组
for(int x = 0 ; x < args.length; x ++){
System.out.println(args[x]) ;
}
}
}
文档说明书：
/*
测试类:
ArrayDemo
测试遍历的数组
*/
class ArrayDemo{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {11,22,44,55,66} ;
//遍历的数组
/*
for(int x = 0 ; x < arr.length; x ++){
System.out.print(arr[x]+" ") ;
}
*/
//单独调用
//printArray(arr) ;
//去掉static,如何访问
//只能通过对象来访问
//ArrayDemo ad = new ArrayDemo() ;
//ad.printArray(arr) ;
//上述代码虽然可以,但是当前测试类的目的,创建其他对象,使用其他对象
//改进:可以将遍历的代码块定义到别的类中
//创建ArrayTool类的对象
//ArrayTool at = new ArrayTool() ;
//at.printArray(arr) ;
//上面这个是通过无参构造方法创建的对象,如何将对象的创建(无参构造方法)禁止调用? private关键字
//编译不通过,被private修饰了
//类名.成员方法() ;
ArrayTool.printArray(arr) ;
}
//将遍历的操作,使用功能代码块包起来
//public static void printArray(int[] arr){
/*
public void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length; x ++){
if(x==arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ");
}
}
}
*/
}
另一个
class ArrayTool{
//无参构造
//public ArrayTool(){}
private ArrayTool(){}
//如果构造方法私有了,只能给成员方法加入static修饰
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length; x ++){
if(x==arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ");
}
}
}
}
简述Student s = new Student() ;完了哪些事情？
附加：static类型内存图解
说明书2：
/*
测试类:
ArrayDemo
测试遍历的数组
ArrayTool中完善了一些功能,遍历,最值,查找
如何将ArrayTool制作成文档说明书呢?
javadoc -d 目录(可以是当前某个目录的路径/或者自定义一个文件目录名) -author -version ArrayTool
以后再学习过程中,会使用jdk---->官方的api
点击---->显示---->索引---->输入"Scanner"----->回车
1)先查看当前这个类是哪个包下 只要不是java.lang下面的都需要导包
2)看最上面的
字段 成员变量
构造器 构造方法 (如果有,就可以创建对象)
方法 成员方法
3)成员方法
看左边
当前返回值类型,需要String类型的---->String类型的返回值的相关方法
看右边:
看方法描述以及形式参数传递的类型
*/
class ArrayDemo{
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {11,22,44,55,66} ;
//static void printArray(int[] arr)
//针对数组进行遍历,获取每一个元素,显示[元素1,元素2,元素3...]
ArrayTool.printArray(arr) ;
//static int getIndex(int[] arr, int value)
//获取数组中的某个元素在数组中第一次出现的索引
int index = ArrayTool.getIndex(arr,60) ;
System.out.println(index) ;
//static int getMax(int[] arr) 获取数组中的最大值
int max = ArrayTool.getMax(arr) ;
System.out.println("数组中的最大值是:"+max) ;
}
}
/**
当前ArrayTool是针对数组进行操作的工具类
@author Apple
@version V1.0
*/
//javadoc: 错误 - 找不到可以文档化的公共或受保护的类 (给哪个类制作文档说明书,必须让当前这个类的权限足够大)
另一个
public class ArrayTool{
/**
私有无参构造,防止外界创建对象
*/
private ArrayTool(){}
/**
针对数组进行遍历,获取每一个元素,显示[元素1,元素2,元素3...]
@param arr 表示当前需要传递一个数组
*/
public static void printArray(int[] arr){
System.out.print("[") ;
for(int x = 0 ; x < arr.length; x ++){
if(x==arr.length-1){
System.out.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ");
}
}
}
/**
获取数组中的最大值
@param arr 表示当前需要传递一个数组
@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 需要传递的数组
@param value 需要查找的元素
@return 返回的就是当前该元素第一次在数组中出现的索引值,如果找不到,返回-1
*/
public static int getIndex(int[] arr,int value){
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x]==value){
return x ;
}
}
//找不到,返回-1
return -1;
}
}
生成的doc目录： doc目录内容：
