Java语言基础(12)
1 构造方法重载
在一个类内部，编写多个构造方法，创建对象的时候，根据需求的不同，调用不同的构造方法创建对象，实现不同的初始化。
案例：Demo1
public class Demo1 {
public static void main(String[] args) {
// 长方体
Box box1 = new Box(100,60,90);
box1.show();
box1.showTiji();
// 正方体
Box box2 = new Box(100);
box2.show();
box2.showTiji();
}
}
class Box{
//属性
int length;
int width;
int height;
//构造方法
//长方体
Box(int length,int width,int height){
this.length = length;
this.width = width;
this.height = height;
}
//正方体
Box(int length){
this.length = length;
this.width = length;
this.height = length;
}
//方法：
void show(){
System.out.println(length+","+width
+","+height);
}
void showTiji(){
int result = length * width * height;
System.out.println("体积是"+result);
}
}
public class Demo2 {
public static void main(String[] args) {
Customer cus1 =
new Customer("韩信",33,"将军");
cus1.show();
Customer cus2 =
new Customer("李白",21,"诗人",
"123","洛阳","bai@126.com");
cus2.show();
cus2.showAll();
}
}
class Customer{
//属性
String name;
int age;
String job;
String password;
String address;
String email;
//构造方法
Customer(String name,int age,
String job){
this.name = name;
this.age = age;
this.job = job;
}
Customer(String name,int age,
String job,String password,
String address,String email){
this.name = name;
this.age = age;
this.job = job;
this.password = password;
this.address = address;
this.email = email;
}
//方法
void show(){
System.out.println(name+","+age+","
+job);
}
void showAll(){
System.out.println(name+","+age+","
+job+","+password+","+address
+","+email);
}
}
2 static
静态的，可以用来修饰属性，方法以及代码块。
1）静态变量(静态属性)：使用static修饰的属性，称为静态变量，静态变量在内存中单独开辟存储空间，不依赖于对象而存在，可以通过类名.静态变量名直接进行访问。
访问方式：
类名.静态变量名
或者
对象名.静态变量名
案例：Demo3
public class Demo3 {
public static void main(String[] args) {
//类名.静态变量名
System.out.println(Foo.name);
// System.out.println(Foo.age);
//age是一个普通属性，只有在创建对象以后，才会为age
//属性开辟存储空间。必须先有对象，然后才可以访问age
//属性
//对象名.静态变量名
Foo foo = new Foo();
System.out.println(foo.name);
System.out.println(foo.age);
}
}
class Foo{
//静态变量不依赖于对象而存在，内存中单独开辟存储空间，
//可以通过类名.静态变量名直接访问。
static String name = "张三";//静态变量
int age = 21;//普通属性
}
2）静态方法：使用static修饰的方法，称为静态方法，不依赖于对象而存在，可以通过类名.静态方法名(参数)直接访问。
案例：Demo4
public class Demo4 {
public static void main(String[] args) {
//类名.静态方法名(参数)
Koo.f1();
//对象名.静态方法名(参数)
Koo koo = new Koo();
koo.f1();
}
}
class Koo{
static void f1(){
System.out.println("今天天气很好！");
}
}
访问方式：
类名.静态方法名(参数)
或者
对象名.静态方法名(参数)
3）如果main方法跟静态方法在同一个类中，在main方法中，可以直接使用静态方法名(参数)来访问静态方法。
案例：Demo5
public class Demo5 {
static void f1(){
System.out.println("今天风真大！");
System.out.println("静态方法");
}
public static void main(String[] args) {
f1();
}
}
public class Demo6 {
public static void main(String[] args) {
for(int i=1;i<=100;i++){
double num = Math.random();
System.out.println(num);
}
}
}
4）sun设计的工具类中经常使用到静态方法，用户可以不用创建该工具类的对象，就可以访问这些静态方法，使用方便。
Math（数学）是sun公司设计的一个工具类，Math内部所有的方法都是静态方法。
random():是一个静态方法，用来返回一个随机的小数，取值范围在[0.0,1.0)
案例：Demo7
public class Demo7 {
//创建一个double类型数组ary，包含200个元素，通过
//Math.random()生成的随机给数组元素赋值。最后
//使用两种for循环，输出每一个元素的值。
public static void main(String[] args) {
double[] ary = new double[200];
for(int i=0;i<=ary.length-1;i++){
ary[i] = Math.random();
}
for(int i=0;i<=ary.length-1;i++){
System.out.println(ary[i]);
}
System.out.println();
System.out.println();
System.out.println();
for(double num : ary){
System.out.println(num);
}
}
}
public class Demo8 {
//在main方法中，创建一个包含了100个元素的double
//类型的数组，使用Math.random()生成的随机数给
//数组元素赋值。
//1 使用两种for循环输出每一个元素的值
//2 求出所有元素的累加之和
//3 求出元素的平均值
public static void main(String[] args) {
double[] ary = new double[100];
for(int i=0;i<=ary.length-1;i++){
ary[i] = Math.random();
System.out.println(ary[i]);
}
System.out.println();
for(double num:ary){
System.out.println(num);
}
double sum = 0;
for(double num:ary){
sum = sum + num;
}
System.out.println("累加之和："+sum);
double avg = sum/100;
System.out.println("平均值是："+avg);
}
}
5）代码块：使用{}括起来的一段代码，每次创建对象的时候都会默认的调用代码块一次。
案例：Demo9
public class Demo9 {
public static void main(String[] args) {
Eoo eoo1 = new Eoo();
Eoo eoo2 = new Eoo();
Eoo eoo3 = new Eoo();
}
}
class Eoo{
{
System.out.println("海阔天空");
System.out.println("我变了 我没变");
System.out.println("喜欢你");
}
}
6）静态代码块：使用static修饰的代码块称为静态代码块，不管创建该类多少个对象，静态代码块只执行一次。
案例：Demo10
public class Demo10 {
public static void main(String[] args) {
Moo moo1 = new Moo();
Moo moo2 = new Moo();
Moo moo3 = new Moo();
}
}
class Moo{
static{
System.out.println("围城");
System.out.println("幻城");
System.out.println("三重门");
}
}
经常使用静态代码块来保存连接数据库的信息，比如密码...
3 this
当前的，现在的
1）this.属性：指代当前的属性。
2）this(参数)：在当前的构造方法中，调用本类中其他的构造方法。跟构造方法重载结合使用。
必须在当前构造方法的第1行使用。
案例：Demo11
public class Demo11 {
public static void main(String[] args) {
Person p1 =
new Person("乔峰",33,"帮主",
"襄阳","feng@126.com");
p1.show();
}
}
class Person{
//属性
String name;
int age;
String job;
String address;
String email;
//构造方法
Person(String name,int age,String job,
String address){
this.name = name;
this.age = age;
this.job = job;
this.address = address;
}
//给每一个属性赋值
Person(String name,int age,String job,
String address,String email){
//this(参数)：在当前的构造方法中调用本类中其他的
//构造方法。必须在当前构造方法的第1行使用。
this(name,age,job,address);
this.email = email;
}
//方法：
void show(){
System.out.println(name+","+age+","
+job+","+address+","+email);
}
}
public class Demo12 {
public static void main(String[] args) {
User user =
new User("张三",29,"经理",
"abc",30000.99,"北京");
user.show();
user.showAll();
}
}
class User{
//属性
String name;
int age;
String job;
String password;
double salary;
String address;
//构造方法
User(String name,int age,String job){
this.name = name;
this.age = age;
this.job = job;
}
User(String name,int age,String job,
String password,double salary,
String address){
this(name,age,job);
this.password = password;
this.salary = salary;
this.address = address;
}
//方法
void show(){
System.out.println(name+","+age+","
+job);
}
void showAll(){
//this.方法名(参数)：在当前的方法中，调用本类中
//其他的方法
this.show();
System.out.println("密码："+password);
System.out.println("工资："+salary);
System.out.println("地址："+address);
}
}
3）this.方法名(参数)：在当前方法中调用本类的其他方法
4 继承
继承的本质就是代码的“复制”。
案例：Demo13
public class Demo13 {
public static void main(String[] args) {
Person2 p1 = new Person2();
p1.name = "李世民";
p1.age = 32;
p1.address = "长安";
p1.show();
Teacher t1 = new Teacher();
t1.name = "李治";
t1.age = 21;
t1.address = "洛阳";
t1.salary = 20000.1;
t1.email = "zhi@126.com";
t1.show();
t1.showAll();
}
}
class Person2{//父类
//属性
String name;
int age;
String address;
//方法
void show(){
System.out.println(name+","+age+","
+address);
}
}
//class 子类 extends 父类
class Teacher extends Person2{//子类
//属性：姓名，年龄，地址，工资，邮箱
//继承父类Person2中的姓名，年龄，地址
double salary;
String email;
//方法：
//继承父类中show()方法
void showAll(){
this.show();//调用父类中继承过来show()方法
System.out.println("工资："+salary);
System.out.println("邮箱："+email);
}
}
1）子类会继承父类中所有的属性和方法
2）格式：
class 子类 extends 父类{
继承父类的属性和方法
在子类中编写其他的属性和方法。
}
案例：Demo14
public class Demo14 {
public static void main(String[] args) {
Worker worker = new Worker();
worker.name = "张翠山";
worker.job = "大侠";
worker.age = 31;
worker.address = "冰火岛";
worker.phone = "13333333333";
worker.salary = 200000.1;
worker.show();
worker.showYearSal();
worker.showAll();
}
}
class Emp{
//属性
String name;
int age;
String job;
double salary;
//方法
void show(){
System.out.println(name+","+age+","+
job+","+salary);
}
void showYearSal(){
double result = salary * 12;
System.out.println(name+"的年薪是"+
result);
}
}
//设计一个父类Emp
//属性：姓名，年龄，职位，工资
//方法：void show():输出姓名，年龄，职位，工资
//void showYearSal():输出姓名和年薪（工资*12）
class Worker extends Emp{
//属性
String address;
String phone;
//方法
void showAll(){
this.show();
System.out.println("地址："+address);
System.out.println("电话："+phone);
}
}
3）Java中永远是单继承，一个子类只能有一个直接的父类，但是可以层层继承。
案例：Demo15
public class Demo15 {
public static void main(String[] args) {
Foo4 foo = new Foo4();
System.out.println(foo.num1);
System.out.println(foo.num2);
System.out.println(foo.num3);
System.out.println(foo.num4);
}
}
class Foo1{
int num1=100;
}
class Foo2 extends Foo1{
//num1
int num2=200;
}
class Foo3 extends Foo2{
//num1,num2
int num3=300;
}
class Foo4 extends Foo3{
//num1,num2,num3
int num4=400;
}
Java语言基础(12)的更多相关文章
- java语言基础02
一.Java语言基础(常量的概述和使用)(掌握) 1:什么是常量 就是在程序的执行过程中其值不发生改变的量. 2:Java中常量的分类 (1):字面值常量 (2):自定义常量(面向对象部分讲解) 3: ...
- Java之--Java语言基础组成—函数
Java语言基础组成-函数 Java语言由8个模块构成,分别为:关键字.标识符(包名.类名.接口名.常量名.变量名等).注释.常量和变量.运算符.语句.函数.数组. 本片主要介绍Java中的函数,函数 ...
- Java之--Java语言基础组成（关键字、标识符、注释、常量和变量、运算符）
Java语言基础组成-关键字.标识符.注释.常量和变量.运算符 Java语言由8个模块构成,分别为:1.关键字:2.标识符(包名.类名.接口名.常量名.变量名等):3.注释:4.常量和变量:5.运算符 ...
- Java语言基础（七）
Java语言基础(七) 今天在公司多呆了会,回来晚了 一.自动类型转换 在Java中,数据是可以转换的 例如可以将byte类型的赋给int类型的 这里希望你了解内存的变化,例如 在这里,我想你应该知 ...
- Java语言基础（六）
Java语言基础(六) 前一章提到的, BigDecimal, DecimalFormat等具体用法,这里就不在说了,网上有许多 一.下面让我们看一个例子(自由落体运动位移) 说明: (1).公式是 ...
- Java入门篇（二）——Java语言基础（下）
上篇说到Java中的变量与常量,接下来就是简单的计算了,首先需要了解一下Java中的运算符. 六.运算符 1. 赋值运算符 赋值运算符即"=",是一个二元运算符(即对两个操作数进行 ...
- 第二十六节：复习Java语言基础-Java的概述，匿名对象，封装，构造函数
Java基础 Java语言概述 Java语言 语言 描述 javaee 企业版 javase 标准版 javame 小型版 JDK JDK(Java开发工具包) Java语言 语言 Java语言 Ja ...
- 第二十二节：Java语言基础-详细讲解位运算符与流程控制语句
位运算符(二进制位运算) 运算符 运算 例子 << 左移 3 << 2 = 12 --> 3 * 2 * 2 =12 >> 右移 3 >> 1 = ...
- 第二十一节：Java语言基础-关键字，标识符，注释，常量和变量，运算符
Java语言基础-关键字,标识符,注解,常量和变量,运算符 class Demo { public static void main(String[] args){ System.out.printl ...
随机推荐
- 使用kubeadm安装kubernetes1.12.2版本脚本【h】
Master节点脚本: #!/bin/sh#使用系统的PATH环境export PATH=`echo $PATH` #停止firewall防火墙,并禁止开机自启动 systemctl stop fir ...
- 3.React中的setstate的几个现象
转载segfault 上面的一篇文章,https://segmentfault.com/a/1190000014498196 1.在同一个方法中多次setState是会被合并的,并且对相同属性的设置只 ...
- Python之数据库
Python之数据库: 1. Mysql 2. pymysql 3. SQLAlchemy Mysql 一.概述 什么是数据库 ? 答:数据的仓库,如:在ATM的示例中我们创建了一个 db 目录,称其 ...
- mybatis报错无法扫描到xml文件
错误:java.io.IOException: Could not find resource com/xxx/xxxMapper.xml 原因:target目录下没有***.xml文件 解决方法:在 ...
- MYsql 客户端下载地址
workbench: https://www.mysql.com/cn/products/workbench/
- Spring4学习回顾之路03—XML配置Bean ,依赖注入的方式
配置Bean的形式可以基于XML文件的方式,也可以基于注解的方式,而Bean的配置方式可以通过全类名(反射),通过工厂方式和FactoryBean. XML形式 <?xml version=&q ...
- go 常量
// 参考:https://studygolang.com/articles/15905?fr=sidebar // iota迭代定义常量 //const配合iota关键字使用,可以定义一组由0开始+ ...
- 搭建kafka集群
1:确认zookeeper集群安装正确,防火墙关闭 2:下载kafka安装文件 cd /usr/local/mydown wget http://mirror.bit.edu.cn/apache/ka ...
- Java HashMap、HashTable与ConCurrentHashMap
一.Java中数据存储方式最底层的两种结构 1.数组:存储空间连续,寻址迅速,增删较慢.(代表:ArrayList) 2.链表:存储空间不连续,寻址慢,增删较快.(代表:LinkedList) 二.哈 ...
- java 字节流与字符流的区别（转）
字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操 ...