JAVA学习第五天

目录

1.类的创建以及简单类方法的引用

2.public String readBook(String name,String…book){}

3.super的使用 this的使用 子类继承父类

4.方法重写与方法重载的比较

5.8种简单数据类型的封装类

6.Get-Set

7.补充

知识点

四种访问修饰符

第四列为非子类

1.类是对象的集合(抽象),对象是类的实例.

2.包名一般为公司域名的倒置 com.baidu.任务的英文简写

3.类里面声明的为全局变量,方法里面声明的是局部变量

4.属性的声明:

访问修饰符(4种) 类型 属性名称;

5.成员方法:

访问修饰符(public protected default默认(不写) private)

返回类型(无返回值写void) 方法名称(首字母小写)(参数类型 参数名称){

有返回值的写return(返回值只能有一个) 一般为方法名

} 需要sysout的 要写在return前面

6.不是全局变量(也就是局部变量)必须赋初始值

7.ASCII中空字符数值等于0

8.java带一个默认的无参构造器,创建任何一种构造器都将默认的无参构造器删除

9.方法里面不可以有方法(不可以相互嵌套) 方法中可以使用if(){} for(){}等等 方法之间可以相互调用 eat(); sleep();

在嵌套区域中不可以重复定义局部变量

10.类中一般包含:成员方法 构造方法 成员变量 不能包含if或者其他的语句

11.引用数据类型方法传递的是复制的地址 简单数据类型是复制的数据

类的创建以及简单类方法的引用

package Test;

public class Student {
public String name;
public String banji;//成员变量
public String xuehao;
public String sex;
private int age;

//无参构造器  构造方法
public  Student(){

}

//成员方法
public void showStudentinformation(String name1,String xuehao1,String  banji1,String  sex1,int age1){
name=name1;
xuehao=xuehao1;
banji=banji1;
sex=sex1;
age=age1;

System.out.println("我的名字是:"+name+"\t"+"我的学号是:"+xuehao+"\t"+"我的班级是:"+banji1+"\t"+"我的性别是"+sex+"\t"+"我的年龄是:"+age);

}

}

package Test;

public class StudentInformation {

public static void main(String[] args) {
// TODO Auto-generated method stub
Student    donghe=new Student();
donghe.showStudentinformation("董贺","201216328","2012163班","男",22);

}

}

可变参数 (String…book) 相当于(String[] book) 只允许放在方法的最后

package Test;

public class Person{// Demo类//首字母大写

private int age;
public String name;// 成员变量 //全局变量
public String sex;
public String   readBook;//字符串类型
//String name,String...book相当于数组 String  book[]
public String  readBook(String name,String...book){
for (int i = 0; i < book.length; i++) {
System.out.println(book[i]);
}
return readBook;

}
//成员方法

public void person(int age1,String name1,String sex1){
//方法体
age=age1;//声明局部变量
name=name1;
sex=sex1;
System.out.println("姓名:"+name+"\n"+"年龄:"+age +  "\n性别:"+sex);
}
//有参构造器    构造方法与类名相同    构造器格式为public    类名(){}
public  Person(int age1, String name1, String sex1) {
age=age1;
name=name1;
sex=sex1;

}
//默认的构造方法

public  Person() {

}
public String sleep(String sleep){
System.out.println("我正在睡觉");
return sleep;
}

public String eat(String food) {
//sleep("122");//方法之间的调用
this.sleep("202");//也可以用this
System.out.println(name+"吃了" + food);
return food;
}

}

package Test;

public class PersonInvoke {
public static void main(String[] args) {// 在java中，main()方法是java应用程序的入口方法。

Person fengjie = new Person();
Person zhangsan = new Person();
fengjie.person(18, "罗玉凤","女");
System.out.println("--------");
zhangsan.person(24, "张三","男");
fengjie.eat("米饭");
zhangsan.sleep("ss");
zhangsan.readBook("我暑假读了","西游记","水浒传","三国演义");

}

}

Get-Set

在类中声明变量 然后右键 source: Generate Getters and Setter

即可快速得到

package Test;

public class GetSet {

private int bookNum;

public void setBookNum(int num1) {

bookNum = num1;
System.out.println(bookNum);

}

public int getBookNum() {

bookNum = 53300;
if (bookNum > 1000) {
System.out.println("不知道多少本");
return 0;//结束

}
System.out.println(bookNum);
return bookNum;

}

}

GetSet_Test

package Test;

public class GetSet_Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
GetSet bookNum=new GetSet();
bookNum.setBookNum(68);
bookNum.getBookNum();
}

}

13.继承 先运行父类后运行子类 先父类属性-构造器 然后子类的属性-构造器

调用方法时如果 子类重写了父类的方法(子类与父类拥有相同的方法名) 会先调用子类的方法

14.重写的方法名 参数 返回值类型必须与父类相同 修饰符要比父类宽松 比如父类为protected 子类重写的方法访问修饰符只可以是protected或者public 若方法不相同先调用父类 若方法相同(方法的重写)先调用子类

方法重写与方法重载的比较

重载

public Car(){
this("");
System.out.println(weight);
System.out.println("Car的无参的构造器");
this.run();
}
public Car(String s){
System.out.println("有参构造器");
}

15.super

super.run(); 调用父类的方法

super(); 调用父类的无参构造器

super(参数); 调用父类的有参构造器

this(参数);必须放在第一行 调用本类的有参的构造器

super.参数(名词) 调用父类的属性

super.method();调用父类的方法

16.封装

将类的某些信息隐藏在类的内部,不允许外部直接访问,而是通过该类的提供的方法实现对隐藏信息的操作和访问

封装的好处:只能通过规定方法访问数据;隐藏类的实现细节;方便加入控制语句;方便修改

package Test;

public class Teacher {
public String name;
public String sex;
public int age;

public int getAge(int age1) {

age = age1;
if (age > 20) {//使用if方法
System.out.println("不该问的事情不要问");
return 0;
}
System.out.println(age);//打印出来
return age;
}

public void teacherInformation(String name1, String sex1, int age1) {
name = name1;
sex = sex1;
age = age1;
System.out.println("老师的姓名:"+name+"\n"+"老师的性别:"+sex+"\n"+"老师的年龄:"+age);
}

}

package Test;

public class TeacherInformation {

public static void main(String[] args) {
// TODO Auto-generated method stub
Teacher teacher=new Teacher();
teacher.getAge(25);
teacher.teacherInformation("zhonghang","男",28);

}

}

8种简单数据类型的封装类

17.Integer k=10; 自动装包为引用数据类型

int h=new Integer(10); 自动拆包为简单数据类型

System.out.println(k==h); // 为true

package com.donghe.svn;

public class Integer8zhongfengzhuangbao {
public static void main(String[] args) {
Integer i=new Integer(10);
Integer j=new Integer(10);
System.out.println(i==j);//false
System.out.println(i.equals(j));//true
//自动拆包装包
Integer  k=10;
//k相当于自动装包为引用数据类型   开辟新的内存地址
System.out.println(j==k);//false
int h=new Integer(10);
int g=new Integer(10);
//h/g拆包为简单数据类型
System.out.println(g==h);//true
System.out.println(k==h);//true
Boolean b=new Boolean(true);
Boolean  b2=new Boolean(true);
System.out.println(b==b2);   //false
System.out.println(b&b2);//true
//复习
String s1="abc";
String s2="abc";
String s3=new String("abc");
String s4=new String("abc");
System.out.println(s1==s2);//true
System.out.println(s2==s4);//false
System.out.println(s2.equals(s4));//true

}
}

super的使用 this的使用 子类继承父类

父类Car

package Test;

public class Car {
public double weight=100;
private  String brand;
private  int  age;
public Car(){
this("");
System.out.println(weight);
System.out.println("Car的无参的构造器");
this.run();
}
public Car(String s){
System.out.println("有参构造器");
}

public void run(){
System.out.println("车会跑");
}

}

子类bus

package Test;

public class Bus   extends Car {

private  int num=100;
public  void  num(){
System.out.println(num);
this.run();

}
public Bus(){
super();

this.run();

}

public  void  run(){

System.out.println("看站牌停车");
//      super.run();
int j=(int) super.weight;
}

public Bus(String s){
super(" ");

}

}

子类Taxi

package Test;

public class Taxi  extends Car {
private int age =10;
public Taxi(){
//      super(" ");
System.out.println(age);
System.out.println("Taxi的无参构造器");
}

}

Test相关注释

///解释
package Test;

public class CarBusTaxi_Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
//      Taxi taxi=new Taxi();//实例化一个对象taxi,要运 行Taxi的构造器...先调用父类的构造器在调用子类的构造器
//      taxi.run();

Bus   bus=new Bus();
System.out.println(bus.weight);
/*按ctrl跳转 public Bus(){}进入Bus的无参构造器  -->super();进入父类Car的无参构造器public Car(){}--> this("");进入Bus的有参构造器 --> super(" ");进入Car的有参构造器
* System.out.println("有参构造器");-->System.out.println(weight);System.out.println("Car的无参的构造器");Bus.run(){}System.out.println("看站牌停车");
* -->System.out.println("车会跑");-->Bus.run(){}System.out.println("看站牌停车");-->System.out.println("车会跑");
*
*/

//      bus.run();
/*Bus.run(){}System.out.println("看站牌停车");-->System.out.println("车会跑");
*
*/

}

}

1.面向对象程序设计特点:封装性 继承性 多态性

2.在静态方法(static)中不可以使用this关键字

在静态方法中不可以直接调用非静态方法

3.不可以将方法内的变量声明为static

binarySearch(array,0,1,8) 包头不包尾

如果包含 返回值索引值 如果不包含返回-排序位置

字符按第一个字母(字母表)排序