1.Tcp协议发送数据
java.net.ConnectException: Connection refused: connect 连接被拒绝
代码实现
[1]客户端代码
public class Client {
public static void main(String[] args) throws Exception{
//1.创建socket的实例
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
String data = "tcp我来了";
//2.返回此套接字的输出流。通过输出流向服务器发送数据
socket.getOutputStream().write(data.getBytes());
//3.关闭socket
socket.close();
}
}
[2]服务器代码
public class ServerClient {
public static void main(String[] args) throws Exception{
//1.创建serversocket对象
ServerSocket ss = new ServerSocket(9999);
//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。 这个对象其实就是发送端的socket对象
Socket socket = ss.accept();
//3.获取客户端发送的数据 要使用输入流
InputStream is = socket.getInputStream();
//4.把数据读取出来
int len =0;
byte buf[] = new byte[1024];
while((len = is.read(buf))!=-1){
String str = new String(buf,0,len);
System.out.println("服务器:"+str);
}
ss.close();
}
}
2.客户端发送数据 数据来自键盘录入
public class Client {
public static void main(String[] args) throws Exception{
//1.创建socket的实例
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
// String data = "tcp我来了";
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String data = scanner.nextLine();
//1.1 当用户输入的是886 跳出while循环
if ("886".equals(data)) {
break;
}
//2.返回此套接字的输出流。通过输出流向服务器发送数据
socket.getOutputStream().write(data.getBytes());
}
scanner.close();
//3.关闭socket
socket.close();
}
}
3.文件上传核心逻辑
代码实现:
[1]客户端代码
public class Client {
public static void main(String[] args) throws Exception{
//1.创建socket的实例
Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);
//2.先读取abc.txt文件内容
FileInputStream fis = new FileInputStream("abc.txt");
int len=0;
byte buf[] = new byte[1024];
while((len=fis.read(buf))!=-1){
//2.返回此套接字的输出流。通过输出流向服务器发送数据
socket.getOutputStream().write(buf, 0, len);
}
fis.close();
//3.关闭socket
socket.close();
}
}
[2]服务器代码
public class ServerClient {
public static void main(String[] args) throws Exception{
//1.创建serversocket对象
ServerSocket ss = new ServerSocket(9999);
//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。 这个对象其实就是发送端的socket对象
Socket socket = ss.accept();
//3.获取客户端发送的数据 要使用输入流
InputStream is = socket.getInputStream();
FileOutputStream fos =new FileOutputStream("abcd.txt");
//4.把数据读取出来 并写到指定文件中
int len =0;
byte buf[] = new byte[1024];
while((len = is.read(buf))!=-1){
fos.write(buf, 0, len);
}
fos.close();
ss.close();
}
}
总结 :客户端上传的是什么文件类型 服务器接收的就应该是什么格式.
udp:datagramSocket DatagramPacket
tcp :socket serversockete
4.枚举(1.5)
package com.itheima.enumtest;
//普通类 来模拟枚举功能 模拟星期
//枚举只能是固定的几个实例
public abstract class WeekDay {
//1.构造方法私有化
private WeekDay(){}
//2.自己创建几个实例 {}代表通过该类的子类完成实例化 就是实现父类为实现的方法
public static WeekDay mon = new WeekDay(){
@Override
public WeekDay nextDay() {
return sun;
}
};
public static WeekDay sun = new WeekDay(){
@Override
public WeekDay nextDay() {
return mon;
}
};
//3.定义一个方法 nextDay //Perosn
/*public WeekDay nextDay(){
if (this == mon) {
return sun;
}else if (this == sun) {
return mon;
}else {
return null;
}
}*/
//4.为了简化if else 语句 我这样定义
public abstract WeekDay nextDay();
//3.默认打印实例 打印地址 重写toString方法 alt + shift + s
@Override
public String toString() {
if (this == mon) {
return "mon";
}else if (this == sun) {
return "sun";
}else{
return "";
}
}
}
public enum Weekday {
// 这个成员默认是静态:
SUN, MON(2), TUE, WED, THRI, FRI(50), SAT;
// 1.定义构造方法
private Weekday() {
System.out.println("1111");
}
//2.定义一个带参数的构造方法
private Weekday(int day) {
System.out.println("22222");
}
}
public enum TrafficLamp {
RED{
@Override
public TrafficLamp nextLamp() {
return TrafficLamp.GREEN;
}
},GREEN{
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},YELLOW{
@Override
public TrafficLamp nextLamp() {
return TrafficLamp.RED;
}
};
//定义下一个灯
public abstract TrafficLamp nextLamp();
}
5.单例设计模式
5.1饿汉式代码写法
//想保证student对象在内存中只有一个实例
//单例设计模式分类 饿汉式 懒汉式
public class Student {
//1.构造方法私有化
private Student(){}
//2.自己创建一个实例 李四
private static Student s = new Student();
//3.对外提供一个获取实例的方法
public static Student getStudent(){
return s;
}
}
5.2 懒汉式代码写法
public class Teacher {
//1.构造方法私有化
private Teacher(){}
//2.自己先不创建 先声明
private static Teacher t;
//3.提供一个方法获取teacher的实例 t1 t2 t3
public synchronized static Teacher getTeacher(){
if (t == null) {
t = new Teacher();
}
return t;
}
}
6.工厂设计模式
1.先定义一个猫和狗的实例
//定义一个猫类
public class Cat extends Anim{
//提供一个吃的方法
public void eat() {
System.out.println("鱼");
}
}
//定义一个狗 类
public class Dog extends Anim{
//提供一个吃的方法
public void eat() {
System.out.println("肉");
}
}
2.由于猫和狗都是动物 所以向上抽取了一个动物类
//抽象一个动物类 提供一个吃的方法
public abstract class Anim {
public abstract void eat();
}
3.创建一个工厂 这个工厂负责猫和狗对象的创建
//这个类就负责猫和狗的创建
public class AnimFactory {
//1.不需要提供new对象的方式获取工厂的实例 所以构造方法私有化
private AnimFactory(){};
//2.对外提供一个创建猫和狗实例的方法 参数代表 获取动物的类型
public static Anim getAnim(String type) {
if ("dog".equals(type)) {
return new Dog();
}else if ("cat".equals(type)) {
return new Cat();
}else {
return null;
}
}
}
7.模板设计模式
代码实现过程
1.定义一个计算时间模板
public abstract class GetTime {
//获取一段逻辑执行需要的时间 这个方法相当于是一个计算时间的模板
public long getCodeTime(){
//1.获取当前系统的时间
long startTime = System.currentTimeMillis();
code(); //具体要计算 的业务逻辑让子类去实现
//2.在获取一下系统时间
long endTime = System.currentTimeMillis()-startTime;
return endTime;
}
public abstract void code();
}
2.定义for循环执行1000万次需要的时间
public class GetForTime extends GetTime {
@Override
public void code() {
//1.1 算出 for循环 需要多长时间
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
}
}
3.定义拷贝视频的逻辑
public class GetCopyVideoTime extends GetTime {
@Override
public void code() {
//这里写拷贝视频的逻辑
//1.2 算出拷贝一段视频需要多长时间
try {
FileInputStream fis = new FileInputStream("test.avi");
FileOutputStream fos = new FileOutputStream("copy.avi");
//流对接操作
int len =0;
byte[] buf = new byte[1024];
while((len=fis.read(buf))!=-1){
fos.write(buf, 0, len);
}
fis.close();
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
8.适配器设计模式
代码实现过程
1.定义一个接口 接口里面有4个方法
public interface User {
public void add();
public void del();
public void update();
public void query();
}
2.定义一个适配器类 Adapter 默认实现这个接口
public class Adapter implements User {
@Override
public void add() {
}
@Override
public void del() {
}
@Override
public void update() {
}
@Override
public void query() {
}
}
3.定义一个具体的实现类 来继承Adapter类 用到哪个方法就重写哪个方法
public class UserImp2 extends Adapter {
@Override
public void add() {
super.add();
}
}
9. 装饰设计模式
代码实现过程
1.定义一个接口 接口里面有个一个打电话功能
public interface Phone {
public void call();
}
2.向上抽取了一个基本的装饰类 基本的装饰类要保证有通话功能
public abstract class BaseDecorate implements Phone {
//子类在装饰的时候 要保证有基本的通话功能
private Phone p;
public BaseDecorate(Phone p){
this.p = p;
}
@Override
public void call() {
this.p.call();
}
}
3.在定义具体的装饰类 比如 播放音乐 加彩铃
public class MusicDecorate extends BaseDecorate {
public MusicDecorate(Phone p) {
super(p);
}
@Override
public void call() {
super.call();
System.out.println("手机可以听音乐了");
}
}
4.定义一个测试类就可以了
public class TestPhone {
public static void main(String[] args) {
//1.手机可以通话了
Iphone iphone = new Iphone();
iphone.call();
System.out.println("-------------");
//2.对手机进行装饰 加彩铃 播放音乐 播放视频 不管对手机怎么装饰 都要保证电话的基本功能
RingDecorate ringDecorate = new RingDecorate(iphone);
ringDecorate.call();
System.out.println("---------***----");
//3.对iphone继续装饰 加音乐
MusicDecorate musicDecorate = new MusicDecorate(iphone);
musicDecorate.call();
}
}
总结设计模式:
1 单例(必须会)
2 工厂设计模式(必须会)
3 模板设计模式(了解)
4.适配器设计模式(必须会)
5.装饰设计模式(了解)
10.Class介绍
public class TestClass {
public static void main(String[] args) throws Exception{
String str = "abc";
//1.获取str 对应的Class对象
Class class1 = str.getClass();//补充:需要写实例,麻烦
//2.类名.class 只要是在java中你能想到的任何类型 都会有一份字节码对象
Class class2 = String.class;//还需要引个包
//3.Class.forName(); 获取Class对象
Class class3 = Class.forName("java.lang.String");//所以一般用这个
System.out.println(class1 == class2);
System.out.println(class2 == class3);
}
}
11.反射
11.1获取person类中构造方法
//获取带私有的构造方法
private static void method2() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取person类中所有的构造方法
Constructor[] declaredConstructors = class1.getDeclaredConstructors();
//3.遍历
for (Constructor constructor : declaredConstructors) {
System.out.println(constructor);
}
}
//alt + shift + M 快速抽取一个方法 获取person类中构造方法 不包含私有的
private static void method1() throws ClassNotFoundException {
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取person类中所有的构造方法
Constructor[] constructors = class1.getConstructors(); //私有获取不到
//3.遍历数组
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
}
11.2获取person类中单个空参构造方法并且实例化
//获取person类中 public Person(){};
private static void method3() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取 public Person(){};构造方法 参数:可变参数
Constructor constructor = class1.getConstructor(); //这个类的实例就代表构造方法
//3.通过构造方法获取person的实例
Object object = constructor.newInstance();
System.out.println(object);
}
11.3
获取person类中单个带参构造方法并且实例化
//获取person类中单个带参构造方法并且实例化
private static void method4() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取 public Person(String name,int age,String address);
Constructor constructor = class1.getConstructor(String.class,int.class,String.class);
//3.通过构造方法获取person的实例
Object object = constructor.newInstance("zhaowei",20,"沙河");
System.out.println(object);
}
11.4获取person类中私有的构造方法
//获取person类中私有的构造方法
private static void method5() throws Exception{
//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取私有的构造方法 private Person(String name)
Constructor constructor = class1.getDeclaredConstructor(String.class);
//3.暴力反射 其实就是调用一个方法 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查
constructor.setAccessible(true);
//3.通过构造方法获取person的实例
Object object = constructor.newInstance("柳岩");
System.out.println(object);
}
11.5 获取person类中成员(属性并且使用)
// 获取所有的属性 包括私有的
private static void method2() throws Exception{
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
// 2.获取person类中所有的属性
Field[] declaredFields = class1.getDeclaredFields();
//3.遍历
for (Field field : declaredFields) {
System.out.println(field);
}
}
// 获取person类中所有的属性
private static void method1() throws Exception {
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
// 2.获取person类中所有的属性 (不要考虑私有)
Field[] fields = class1.getFields();
// 3.遍历
for (Field field : fields) {
System.out.println(field);
}
}
11.6获取单个属性并且使用
//获取person类中address属性并且
private static void method3() throws Exception{
// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名 类名
Class class1 = Class.forName("com.itheima.classtest.Person");
//2.获取address属性并且使用 参数:获取哪个属性
Field field = class1.getField("address");
//3.通过构造方法获取person的实例
Constructor constructor = class1.getConstructor();
Object obj = constructor.newInstance();
System.out.println("---"+obj);
//3.给address属性赋值 参数1:代表person的实例
field.set(obj, "上海");
System.out.println(obj);
}
12.今天总结
1.tcp协议 了解 ☆
2.枚举
☆
☆
☆
3.单例
☆
☆
☆
4.工厂
☆
☆
☆
5.适配器
☆
☆
☆
6.模板
☆
☆
7.装饰
☆
8.Class类
☆
☆
☆
9.反射
☆
☆
☆
复习:
1.枚举:(具体见day2——4)
原理模拟 :枚举就是一个把构造方法私有的抽象类。
私有构造方法是为了不让别人通过new随意建立对象,而只能通过类名调用在本身已经定义好的对象(所以在本类中新建对象时必须用static修饰)。
抽象是为了方法实现。
方法实现:先在本类中定义一个抽象方法,新建对象时通过加{匿名内部类类型的子类}实现抽象方法。
2.单例设计模式:(day2——5)
原理:
懒汉式:私有化构造,直接new对象,对外提供获取方法;
饿汉式:私有化构造,先定义对象,但是不初始化。在获取方法里面判断对象是否为空,为空再新建。
(饿汉式容易出现线程安全问题,获取方法上要加synchronize,一般不用饿汉式,两种方法的构造都要加static,因为要让外界直接调用)
3.工厂设计模式:(day2——6)
原理:抽取各个对象类的共性,建立一个抽象的父类,再用一个工厂对调用方法加工(工厂获取客户需求,内部调用对象并反馈)。
4.模板设计模式:
原理:做一个模板,用子类继承模板,并覆盖部分方法,以实现特殊功能。
5.适配器设计模式:
原理:先做一个接口,然后用一个适配器实现接口中所有的方法,但是方法的内容为空,当有需要用到这些方法的时候,再新建一个类继承适配器并覆盖
需要用到的方法
6.反射:
原理: 反射就是把java中相应的成分(构造方法 成员 方法)映射成相应的类.
1. 构造方法 反射成 constructor类
①
获取单个用
get
Constructor
(
参数类型.参数名 如:原构造是 String a 在这里变为--->
String.class
)方法,获取多个用
get
Constructor
②
如果要获取私有的,用
getDeclared
Constructors
(),
getDeclared
Constructor
(参数类型.class,...) 如:原构造是 String a 在这里变为---> String.calss
私有需要暴力反射:
constructor.setAccessible(true);
例子: 演示
获取空参构造并实例。(里面是可以加参数的,下面的例子是空参的例子。)
Constructor
constructor
=
class1
.
getConstructor
();
Object
obj
=
constructor
.
newInstance
();实例化
2. 成员 反射成 field类
① 获取单个用getField(里面加需要获取的成员名,+加引号)方法,获取多个用getFields
②
如果要获取私有的,用
getDeclaredFields(),
getDeclaredField("成员名")
获取单个并实例化,用
1.
获取空参构造实例。
Constructor
constructor
=
class1
.
getConstructor
();
Object
obj
=
constructor
.
newInstance
();
2.通过set,给空参实例赋值成员属性。
field
.
set
(
obj
,
"上海"
);
System
.
out
.
println
(
obj
);
3. 方法 反射成 method类
同上:
getDeclaredMethod,
getDeclaredMethods,
getMethod,
getMethods
12.今天总结
1.tcp协议 了解 ☆
2.枚举 ☆☆☆
3.单例 ☆☆☆
4.工厂 ☆☆☆
5.适配器 ☆☆☆
6.模板 ☆☆
7.装饰 ☆
8.Class类 ☆☆☆
9.反射 ☆☆☆