java封装的四个关键字,JAVA-Day4

李星河

于 2021-03-22 02:21:03 发布

阅读量451

点赞数

文章标签： java封装的四个关键字

小类型向大类型转换

不同类型的数据经常出现相互转换的现象.

1, 在Java中小类型向大类型的转换会自动完成, 即不需要程序员编写额外的代码, 由JVM负责, 自动类型转换也叫"隐式类型转换"

2, 自动转换的规则: 符号位会自动扩展, 最高位负数补1, 正数补0.

3, 自动类型转换包含以下情况: (1):byte->short->int->long->float->double (2):int和char类型的数据在某些情况下可以自动相互转换

4, 整数到浮点数转换会损失精确度

代码例: int i = -2;

long l = i;

System.out.println(i+":"+Integer.toBinaryString(i));//-2:11111111111111111111111111111110

//long类型输出的值, 高于32位的自动补1, 其余不变

System.out.println(l+":"+Long.toBinaryString(l));//-2:1111111111111111111111111111111111111111111111111111111111111110

5, 小类型向大类型转换一般情况下是安全的

6, 当小类型的精度高于大类型时要注意精度丢失的隐患.

int类型转换为float类型:

int i = 0x1000001;

float f = i;

//float类型变量在存储int类型的变量时候丢失了最后一位: 原因是:float类型的位数是23位

System.out.println(Integer.toBinaryString(i)+":"+i);//1000000000000000000000001:16777217

//因为Float里面没有这个转成二进制的方法(toBinaryString), 所以需要先强制转换为int类型,然后再转成二进制

System.out.println(Integer.toBinaryString((int)f)+":"+f);//1000000000000000000000000:1.6777216E7

long类型转换为double类型

当小类型向大类型转换时候,如果小类型的精度值大于大类型, 要注意精度丢失的问题

大类型向小类型转换

1, 强转类型转换-简称强转

2, 强制类型类型转换时, 要注意边界数风险问题

int类型与char类型的转换

Java对char类型的数据在底层是按int类型来处理的

int类型与char类型在赋值时可自动转换

代码例: char c = 65;

int i = 'B';

System.out.println(c+","+i);//A,66

字符类型的数据可进行数值计算:

代码例: char c = 'A';

int i = c+1;

c = (char) (c+1);

System.out.println(c+":"+i);//B:66

通过args数组获取数据

通过main方法的args数组可以从控制台获取一组字符串数据

案例: 给main方法的args数组输入两个整数, 对这两个整数进行四则运算

注意: 在运行前先要给args数组赋值: run-run configurations-arguments-赋值即可

public static void main(String[] args) {

//parseInt把字符串转换为int类型

int a = Integer.parseInt(args[0]);

int b = Integer.parseInt(args[1]);

System.out.println(a+"+"+b+"="+(a+b));//10+3=13

System.out.println(a+"-"+b+"="+(a-b));//10-3=7

System.out.println(a+"*"+b+"="+a*b);//10*3=30

System.out.println(a+"/"+b+"="+a/b);//10/3=3

}

通过Scanner从控制台获取数据

1, Scanner类用于扫描从控制台输入的数据, 可以接收字符串和基本数据类型的数据

2, Scanner类位于java.util.Scanner包中

Scanner类的常用方法

1, String next(); 作用: 接收控制台输入的一个字符串, 以空格或回车作为一次数据输入的结束

2, String nextLine(); 作用: 接收控制台输入的一个字符串,以回车作为输入的结束, 所以可以接收空格作为字符串的一部分

3, int nextInt(); 作用: 接收控制台输入的一个int类型的数据

4, double nextDouble(); 作用: 接收控制台输入的一个double类型的数据

5, boolean nextBoolean(); 作用: 接收控制台输入的一个boolean类型的数据

6, 输入char类型的数据 : Scanner类型没有提供直接输入char类型的方法, 可以通过charAt()方法从next()或nextLine()获取输入的字符

char String.charAt(int index); 作用: 从字符串中获取指定下表的字符, 下标从0开始. 例如:"abc".charAt(0)的结果是a. "abc".charAt(1)的结果是b

例如; next().charAt(0); 从控制台输入的字符串中获取第一个字符

通过Scanner从控制台接收数据的步骤:

step1: 创建Scanner类的一个对象示例: Scanner scanner = new Scanner(System.in);//System.in是用来指定scanner从控制台输入的数据

step2, 通过scanner调用next等方法, 接收控制台输入的数据. 示例: System.out.println("姓名: "); String name = scanner.next();

代码例如: public static void main(String[] args) {

//姓名, 性别, 年龄等都需要从控制台输入

//步骤一. 创建Scanner对象

Scanner scanner = new Scanner(System.in);

//步骤二, 向控制台输出文本

System.out.println("姓名:");

String name = scanner.next();

System.out.println("性别:");

char sex = scanner.next().charAt(0);

System.out.println("年龄:");

int age = scanner.nextInt();

System.out.println("身高:");

double height = scanner.nextDouble();

System.out.println("性格:");

String type = scanner.next();

System.out.println("嗨, 大家好, 俺叫"+name+"性别是"+sex+"今年"+age+"身高是"+height+"性格比较"+type+", 希望大家能喜欢俺");}

封装性

1, 封装性的产生目的保护某些属性和方法不被外部所看见

2, 封装的实现为属性和方法进行封装是通过关键字private声明的

3, 封装性的产生目的保护某些属性和方法不被外部所看见

4, 封装的实现为属性和方法进行封装是通过关键字private声明的实现该属性的set和get方法, 为外部所访问

代码

class Person{

private int age;

private String name;

public void tell(){

System.out.println("年龄:"+getAge()+" \n"+"姓名:"+getName());

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}}

public class ClassDemo1 {

public static void main(String[] args) {

Person per = new Person();

per.setAge(30);//设置年龄

per.setName("哈哈");

per.tell();}

匿名对象

1, 匿名对象就是没有名字的对象, 如果程序中只是用一次改对象, 就可以使用匿名对象的方式

代码:

class Student{

public void tell(){

System.out.println("Hello");

}

public class ClassDemo2 {

public static void main(String[] args) {

//正常方式访问

//Student stu = new Student();

//stu.tell();

//匿名对象方式访问

new Student().tell();}

构造方法

1, 格式: 如图

090e9040868c

2, 注意点: 1)构造方法名称必须要与类名一致 , 2)构造方法无返回值

3, 构造方法主要是为类中的属性进行初始化

4, 每个类在实例化之后都会调用构造方法, 如果没有构造方法, 程序在编译的时候会创建一个无参的什么都不做的构造方法

5, 构造方法也可以进行重载 � 重载(两个方法,同名不同参.参数个数不同)

代码:

class Person {

int age;

String name;

//构造方法

public Person(int a, String n){

age = a;

name = n;

System.out.println("姓名"+name+" 年龄"+age);

}

//构造方法

public Person(int a){

age = a;

System.out.println("年龄 "+age);

}

//上面重载: 方法同名不同参

public class ClassDemo01 {

public static void main(String[] args) {

//Person per = new Person(11,"lisi");

Person per1 = new Person(13);

}}

Java面向对象多态性

1, 多态性的体现: 方法的重载和重写, 对象的多态性

2, 对象的多态性: 向上转型: 程序会自动完成父类父类对象 = 子类实例

向下转型: 强制类型转换子类子类对象 = (子类)父类实例

代码:

class A{

public void tell1(){

System.out.println("A-tell1");

}

public void tell2() {

System.out.println("A-tell2");

}

class B extends A{

public void tell1() {

System.out.println("B-tell1");

}

public void tell3() {

System.out.println("B-tell3");

}

public class PolDemo01 {

public static void main(String[] args) {

//向上转型

//B b = new B();

//A a = b;

//a.tell1();

//a.tell2();

//向下转型前必须要先向上转型

A a = new B();

B b = (B)a;

b.tell1();

b.tell2();

b.tell3();}}

代码:

class A{

public void tell1() {

System.out.println("A--tell1");

}

class B extends A{

public void tell2() {

System.out.println("B -- tell2");

}}

class C extends A{

public void tell3() {

System.out.println("C--tell3");

}}

public class PolDemo02 {

public static void main(String[] args) {

say(new B());

say(new C());

}

public static void say(A a){

a.tell1();

}}

instanceof 关键字

1, 在Java中可以使用instanceof关键字判断一个对象到底是不是一个类的实例 ; A a = new A(); --(a instanceof A)

面向对象抽象类应用

代码:

//建立一个抽象类

abstract class People{

//两个属性

private int age;

private String name;

//连个属性的set和get方法

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

//构造方法

public People(int a, String n){

//System.out.println("年龄:"+age+" 姓名"+name);

this.age = a;

this.name = n;

}

//共有的抽象方法

public abstract void want();

}

//Student类, 扩展自People类

class Student extends People{

private int scroe;

public int getScroe() {

return scroe;

}

public void setScroe(int scroe) {

this.scroe = scroe;

}

public Student(int a, String n, int s) {

super(a, n);

this.scroe = s;

}

@Override

public void want() {

System.out.println("姓名"+getName()+" 年龄"+getAge() + "成绩" + getScroe());

}

//Worker类扩展自People

class Worker extends People{

private int money;

public int getMoney() {

return money;

}

public void setMoney(int money) {

this.money = money;

}

public Worker(int a, String n, int m) {

super(a, n);

this.money = m;

}

@Override

public void want() {

System.out.println("姓名"+getName()+" 年龄"+getAge() + "工资" + getMoney());

}

public class AbsDemo {

public static void main(String[] args) {

Student stu = new Student(10, "hh", 99);

stu.want();

Worker w = new Worker(32, "ww", 2000);

w.want();

}}

Java面向对象,接口的使用

代码:

//首先需要有一个公共的接口USB

interface USB{

//两个抽象方法

void start();

void stop();

}

//定义一个电脑

class Computer{

public static void work(USB u) {

u.start();

System.out.println("工作中");

u.stop();

}

//创建U盘类, 扩展自USB

class USBDisk implements USB{

@Override

public void start() {

// TODO Auto-generated method stub

System.out.println("U盘开始工作");

}

public void stop() {

// TODO Auto-generated method stub

System.out.println("U盘停止工作");

}

//创建打印机

class Printer implements USB{

@Override

public void start() {

System.out.println("打印机开始工作");

}

@Override

public void stop() {

System.out.println("打印机停止工作");

}

public class InterDemo01 {

public static void main(String[] args) {

Computer.work(new USBDisk());

Computer.work(new Printer());}}

�继承的实现

1, 继承的基本概念 : 扩展父类的功能

2,Java中使用extends关键字完成继承 class 子类 extends 父类{}

代码:

class Person{

private int age;

private String name;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public void tel() {

//System.out.println("姓名"+getName()+" 年龄"+getAge());

}

class Student extends Person{

private int score;

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

public void want() {

System.out.println("成绩"+getScore()+"姓名"+getName()+" 年龄"+getAge());

}

public class ExtendsDemo01 {

public static void main(String[] args) {

Student stu = new Student();

stu.setAge(13);

stu.setName("zhangsan");

stu.setScore(100);

stu.tel();

stu.want();

}

李星河

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java封装的四个关键字,JAVA-Day4

小类型向大类型转换不同类型的数据经常出现相互转换的现象.1, 在Java中小类型向大类型的转换会自动完成, 即不需要程序员编写额外的代码, 由JVM负责, 自动类型转换也叫"隐式类型转换"2, 自动转换的规则: 符号位会自动扩展, 最高位负数补1, 正数补0.3, 自动类型转换包含以下情况: (1):byte->short->int->long->float->d...
复制链接

扫一扫